A bracket sequence is a string containing only characters "(" and ")". A regular bracket sequence is a bracket sequence that can be transformed into a correct arithmetic expression by inserting characters "1" and "+" between the original characters of the sequence. For example, bracket sequences "()()" and "(())" are regular (the resulting expressions are: "(1)+(1)" and "((1+1)+1)"), and ")(", "(" and ")" are not.

Subsequence is a sequence that can be derived from another sequence by deleting some elements without changing the order of the remaining elements.

You are given a regular bracket sequence s and an integer number k. Your task is to find a regular bracket sequence of length exactly k such that it is also a subsequence of s.

It is guaranteed that such sequence always exists.

Input

The first line contains two integers n and k (2 ≤ k ≤ n ≤ 2 ⋅ 10^5, both n and k are even) — the length of s and the length of the sequence you are asked to find.

The second line is a string s — regular bracket sequence of length n.

Output

Print a single string — a regular bracket sequence of length exactly k such that it is also a subsequence of s.

It is guaranteed that such sequence always exists.

Examples

Input

6 4
()(())


Output

()()


Input

8 8
(()(()))


Output

(()(()))
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.security.interfaces.DSAKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class main {

    public static class in   {
        static BufferedReader reader;
        static StringTokenizer tokenizer;

        static void init(InputStream input) throws FileNotFoundException {
             //reader = new BufferedReader(new FileReader("jacks_candy_shop.txt"));
            reader = new BufferedReader(new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        static long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }

    public static long comp(int n, int r) {
        r = Math.min(r, n - r);
        long ans = 1;
        for (int i = 1; i <= r; i++) {
            ans = ans * (long) (n - r + i) / (long) i;
        }
        return ans;

    }


    public static int gcd(int x, int y) {
        if (y == 0)
            return x;
        return gcd(y, x % y);
    }


    public static class point implements Comparable<point>  {
        String a ;
        int idx;

        point( String a, int idx) {
            this.a = a;
            this.idx = idx;
        }

        @Override
        public int compareTo(point o) {
            if (o.idx < idx)
                return 1;
            else if (o.idx > idx)
                return -1;
            return 0;
        }
    }

    // for bad input
    static String ReadLn(int maxLg) {
        byte lin[] = new byte[maxLg];
        int lg = 0, car = -1;
        String line = "";

        try {
            while (lg < maxLg) {
                car = System.in.read();
                if ((car < 0) || (car == '\n'))
                    break;
                lin[lg++] += car;
            }
        } catch (IOException e) {
            return (null);
        }

        if ((car < 0) && (lg == 0))
            return (null);
        return (new String(lin, 0, lg));
    }







    public static class node implements Comparable<node>{
        int value;
        int cost;
        node(int value, int cost){
            this.value = value;
            this.cost = cost;
        }
        @Override
        public int compareTo(node o) {
            if(o.cost < cost)
                return 1;
            else if(o.cost > cost)
                return -1;
            return 0;
        }
    }



    public static void main(String[] args) throws IOException {
        StringBuilder qq = new StringBuilder();
        in.init(System.in);
        PrintWriter out = new PrintWriter(System.out);
        BufferedReader inp = new BufferedReader(
                new InputStreamReader(System.in));


        int n = in.nextInt();
        int m =in.nextInt();
        String a = in.next();

        String ans = "";
        int open = 0;
        int c = 0;
        for (int i = 0; i < a.length() && ans.length() < m; i++) {
            if(a.charAt(i) =='('){
                if(open + 1 <= m - c){
                    out.print(a.charAt(i));
                    c++;

                    open++;
                }
            }else{
                if(open > 0){
                    out.print(a.charAt(i));
                    c++;

                    open--;
                }
            }
        }

        out.println();





        out.close();
    }

}