{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE UndecidableInstances #-}

module Main where

import Control.Category hiding (id, (.))
import Control.Exception (assert)
import Control.Monad
import Control.Monad.ST
import Control.Monad.State.Strict
import qualified Data.ByteString.Char8 as BS
import Data.List as List
import Data.Maybe
import Data.Set as Set
import Data.Vector.Unboxing ((!))
import qualified Data.Vector.Unboxing as U
import qualified Data.Vector.Unboxing.Mutable as UM
import Debug.Trace
import GHC.Generics

-- import System.TimeIt as Time

readInt = fst . fromJust . BS.readInt

readIntList = Prelude.map readInt . BS.words

getInt = readInt <$> BS.getLine

getIntList = readIntList <$> BS.getLine

range begin end = [begin .. (end - 1)]

partitionIdx vec pred =
  assert (U.length vec >= 0) $
    if pred (vec U.! 0) == False
      then 0
      else loop 0 (U.length vec)
  where
    loop begin end =
      if end == begin + 1
        then end
        else
          let !mid = (begin + end) `div` 2
           in if pred (vec U.! mid) then loop mid end else loop begin mid

-- data Point = Pt {-# UNPACK #-} Int {-# UNPACK #-} Int
--   deriving (Generic)
--   deriving (U.Unboxable) via U.Generics Point

-- ptX :: Point -> Int
-- ptX (Pt x y) = x

-- ptY :: Point -> Int
-- ptY (Pt x y) = y

main :: IO ()
main = do
  n <- getInt
  s <- BS.getLine
  let table = U.constructN (n + 1) f
        where
          f vec = case (U.length vec) of
            0 -> 0 :: Int
            i -> prev + diff
              where
                prev = vec ! (i - 1)
                paren = BS.index s (i - 1)
                diff = case paren of
                  '(' -> 1
                  ')' -> -1
      openCnt = - (U.minimum table)
      closeCnt = (table ! n) + openCnt
  BS.putStrLn $ BS.concat [BS.pack (replicate openCnt '('), s, BS.pack (replicate closeCnt ')')]