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.*;
import java.math.*;
import java.util.*;
import static java.lang.Math.*;

public class SuperClassss{

    static class Run{
        static void main(){
            int n = in.nextInt(), k = in.nextInt();
            ArrayList<Integer> st = new ArrayList<>();
            boolean del[] = new boolean[n];
            String s = in.next();
            for(int i = 0; i<size(s); i++){
                if(chAt(s, i)=='('){
                    st.add(i);
                }
                else{
                    if(n!=k){
                        del[st.get(size(st)-1)] = true;
                        del[i] = true;
                        st.remove(size(st)-1);
                        k+=2;
                    }
                    else{
                        st.remove(size(st)-1);
                    }
                }
            }
            for(int i = 0; i<size(s); i++){
                if(!del[i]) print(chAt(s, i));
            }
        }
    }

    public static void main(String[] args) {
        Run.main();
        out.flush();
    }

    static Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(System.out);
    static StreamTokenizer in1 = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static BufferedReader in2 = new BufferedReader(new InputStreamReader(System.in));

    public static char chAt(String s, int pos){
        return s.charAt(pos);
    }

    public static char chAt(StringBuilder s, int pos){
        return s.charAt(pos);
    }

    public static int[] prefix_function(String s, String t){
        String edit = s+"#"+t;
        return prefix_function(edit);
    }

    public static int[] prefix_function(String edit){
        int len = edit.length(), pi[] = new int[len];
        for(int i = 1; i<len; i++){
            int j = pi[i-1];
            while(j>0 && edit.charAt(i)!=edit.charAt(j)) j = pi[j-1];
            if(edit.charAt(i)==edit.charAt(j)) j++;
            pi[i] = j;
        }
        return pi;
    }

    public static int size(String obj){
        return obj.length();
    }

    public static int size(StringBuilder obj){
        return obj.length();
    }

    public static int size(Collection<?> obj){
        return obj.size();
    }

    public static int size(AbstractMap<?, ?> obj){
        return obj.size();
    }

    public static int size(AbstractCollection<?> obj){
        return obj.size();
    }

    public static<T> int size(T[] obj){
        return obj.length;
    }

    public static <T> void print(T... args) {
        for (T x : args) {
            out.print(x.toString());
        }
    }

    public static <T> void println(T... args) {
        print(args);
        out.println();
    }

    public static long nextLong() {
        try {
            in1.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (long) in1.nval;
    }

    public static int nextInt() {
        try {
            in1.nextToken();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return (int) in1.nval;
    }

    static String nextLine(){
        return in.nextLine();
    }
    public static String nextString() {
        try {
            return in2.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String next(){
        return in.next();
    }

    public static char nextChar() {
        try {
            return (char) in2.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return '!';
    }

    public static void readArray(int[] array) {
        for (int i = 0; i < array.length; i++)
            array[i] = nextInt();
    }

    public static void readArray(long[] array) {
        for (int i = 0; i < array.length; i++)
            array[i] = nextInt();
    }

    public static void readArray(char[] array) {
        for (int i = 0; i < array.length; i++)
            array[i] = nextChar();
    }

    public static void readArray(String[] array) {
        for (int i = 0; i < array.length; i++)
            array[i] = nextString();
    }

    public static void readArray(StringBuilder[] array) {
        for (int i = 0; i < array.length; i++)
            array[i] = new StringBuilder(nextString());
    }

    public static int gcd(int a, int b) {
        while (b != 0) {
            int tmp = a % b;
            a = b;
            b = tmp;
        }
        return a;
    }

    public static int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    public static int min(int...args){
        Arrays.sort(args);
        return (args[0]);
    }

    public static int max(int...args){
        Arrays.sort(args);
        return(args[args.length-1]);
    }

    static double s(int x1, int y1, int x2, int y2, int x3, int y3) {
        return Math.abs((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1)) / 2.0;
    }

    public static LinkedList<Integer> isPrimeList(int n) {
        LinkedList<Integer> res = new LinkedList<>();
        boolean prime[] = new boolean[n];
        Arrays.fill(prime, true);
        prime[1] = false;
        for (int i = 2; i * i < n; i++) {
            if (prime[i])
                for (int j = i * i; j < n; j += i)
                    prime[j] = false;
        }
        for (int i = 2; i < n; i++)
            if (prime[i]) res.add(i);
        return res;
    }

    public static BigInteger bigSqrt(BigInteger n) {
        BigInteger a = BigInteger.ONE.shiftLeft((n.bitLength() + 1) / 2), next = a.subtract(BigInteger.ONE);
        while (next.compareTo(a) < 0) {
            a = next;
            next = a.add(n.divide(a)).divide(BigInteger.valueOf(2));
        }
        return a;
    }
}