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