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