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