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