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