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