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