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