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