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