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