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