One day, Yuhao came across a problem about checking if some bracket sequences are correct bracket sequences.

A bracket sequence is any non-empty sequence of opening and closing parentheses. A bracket sequence is called a correct bracket sequence if it's possible to obtain a correct arithmetic expression by inserting characters "+" and "1" into this sequence. For example, the sequences "(())()", "()" and "(()(()))" are correct, while the bracket sequences ")(", "(()" and "(()))(" are not correct.

Yuhao found this problem too simple for him so he decided to make the problem harder. You are given many (not necessarily correct) bracket sequences. The task is to connect some of them into ordered pairs so that each bracket sequence occurs in at most one pair and the concatenation of the bracket sequences in each pair is a correct bracket sequence. The goal is to create as many pairs as possible.

This problem unfortunately turned out to be too difficult for Yuhao. Can you help him and solve it?

Input

The first line contains one integer n (1 ≤ n ≤ 10^5) — the number of bracket sequences.

Each of the following n lines contains one bracket sequence — a non-empty string which consists only of characters "(" and ")".

The sum of lengths of all bracket sequences in the input is at most 5 ⋅ 10^5.

Note that a bracket sequence may appear in the input multiple times. In this case, you can use each copy of the sequence separately. Also note that the order in which strings appear in the input doesn't matter.

Output

Print a single integer — the maximum number of pairs which can be made, adhering to the conditions in the statement.

Examples

Input


7
)())
)
((
((
(
)
)


Output


2


Input


4
(
((
(((
(())


Output


0


Input


2
(())
()


Output


1

Note

In the first example, it's optimal to construct two pairs: "(( )())" and "( )".
import java.io.*;
import java.util.*;

public class Stack3 {

    static class Reader {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }
            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null)
                return;
            din.close();
        }
    }

    static Reader sc = new Reader();
    static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    static long mod = (long) (1e9 + 7);

    public static void main(String[] args) throws IOException {
        /*
         * For integer input: int n=inputInt();
         * For long input: long n=inputLong();
         * For double input: double n=inputDouble();
         * For String input: String s=inputString();
         * Logic goes here
         * For printing without space: print(a+""); where a is a variable of any datatype
         * For printing with space: printSp(a+""); where a is a variable of any datatype
         * For printing with new line: println(a+""); where a is a variable of any datatype
         */
        Scanner sc = new Scanner(System.in);
      Map<Integer,Integer> map=new HashMap<>();
        int n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            String s=sc.next();
            int sum=0;
            for(int j=0;j<s.length();j++){
                char ch=s.charAt(j);
                if(ch=='('){
                    sum++;
                }else {
                    sum--;
                }
            }
            if(checkcorrect(s,sum)){
                map.putIfAbsent(sum,0);
                map.put(sum,map.get(sum)+1);
            }
        }
        long ans=0;
        for(Integer integer:map.keySet()){
            int num=integer;
            int num1=-1*integer;
            if(num!=0&&map.containsKey(num1)){
                int min=Math.min(map.get(num),map.get(num1));
                map.put(num,map.get(num)-min);
                map.put(num1,map.get(num1)-min);
                ans+=min;

            }
        }
        if(map.containsKey(0)){
            ans+=map.get(0)/2;
        }
        System.out.println(ans);


        bw.flush();
        bw.close();


    }

    public static boolean checkcorrect(String s,int p){
        if(p==0){
            int t=0;
            for(int i=0;i<s.length();i++){
                char ch=s.charAt(i);
                if(ch=='('){
                    t++;
                }else if(t==0){
                    return false;
                }else {
                    t--;
                }
            }
            return t==0;
        }else if(p<0){
            int t=0;
            for(int i=0;i<s.length();i++){
                char ch=s.charAt(i);
                if(ch=='('){
                    t++;
                }else if(t>0){
                    t--;
                }
            }
            return t==0;
        }else {
            int t=0;
            for(int i=0;i<s.length();i++){
                char ch=s.charAt(i);
                if(ch=='('){
                    t++;
                }else if(t>0){
                    t--;
                }else {
                    t=-1;
                    break;
                }
            }
            return t>=0;
        }
    }


    public static void dfs1(List<List<Integer>> g, boolean[] visited, Stack<Integer> stack, int num) {
        visited[num] = true;
        for (Integer integer : g.get(num)) {
            if (!visited[integer]) {
                dfs1(g, visited, stack, integer);
            }
        }
        stack.push(num);
    }

    public static void dfs2(List<List<Integer>> g, boolean[] visited, List<Integer> list, int num, int c, int[] raj) {
        visited[num] = true;

        for (Integer integer : g.get(num)) {
            if (!visited[integer]) {
                dfs2(g, visited, list, integer, c, raj);
            }
        }
        raj[num] = c;
        list.add(num);

    }

    public static int inputInt() throws IOException {
        return sc.nextInt();
    }

    public static long inputLong() throws IOException {
        return sc.nextLong();
    }

    public static double inputDouble() throws IOException {
        return sc.nextDouble();
    }

    public static String inputString() throws IOException {
        return sc.readLine();
    }

    public static void print(String a) throws IOException {
        bw.write(a);
    }

    public static void printSp(String a) throws IOException {
        bw.write(a + " ");
    }

    public static void println(String a) throws IOException {
        bw.write(a + "\n");
    }


    public static long getAns(int[] ar, int c, long[][] dp, int i, int sign) {
        if (i < 0) {
            return 1;
        }

        if (c <= 0) {
            return 1;
        }

        dp[i][c] = Math.max(dp[i][c], Math.max(ar[i] * getAns(ar, c - 1, dp, i - 1, sign), getAns(ar, c, dp, i - 1, 1)));
        return dp[i][c];
    }


    public static long power(long a, long b, long c) {
        long ans = 1;
        while (b != 0) {
            if (b % 2 == 1) {
                ans = ans * a;
                ans %= c;
            }
            a = a * a;
            a %= c;
            b /= 2;
        }
        return ans;
    }

    public static long power1(long a, long b, long c) {
        long ans = 1;
        while (b != 0) {
            if (b % 2 == 1) {
                ans = multiply(ans, a, c);
            }
            a = multiply(a, a, c);
            b /= 2;

        }
        return ans;

    }

    public static long multiply(long a, long b, long c) {
        long res = 0;
        a %= c;
        while (b > 0) {
            if (b % 2 == 1) {
                res = (res + a) % c;
            }
            a = (a + a) % c;
            b /= 2;
        }

        return res % c;

    }

    public static long totient(long n) {
        long result = n;
        for (long i = 2; i * i <= n; i++) {
            if (n % i == 0) {
                //sum=sum+2*i;
                while (n % i == 0) {
                    n /= i;
                    // sum=sum+n;
                }
                result -= result / i;

            }
        }
        if (n > 1) {
            result -= result / n;

        }
        return result;
    }


    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    public int sumOfFlooredPairs(int[] nums) {
        // long sum=0;
        long mod = (long) (1e9 + 7);
        Arrays.sort(nums);
        long[] numerator = new long[nums.length];
        long[] denominator = new long[nums.length];

        long[] numerator1 = new long[nums.length];
        long[] denominator1 = new long[nums.length];

        long num = 1;
        long den = nums[0];
        numerator[0] = 1;
        denominator[0] = den;
        long num1 = 1;
        long den1 = nums[nums.length - 1];
        numerator1[nums.length - 1] = 1;
        denominator1[nums.length - 1] = den1;


        for (int i = 1; i < nums.length; i++) {

            long gcd1 = gcd(denominator[i - 1], nums[i]);
            long lcm = (denominator[i - 1] * nums[i]) / gcd1;
            long n1 = lcm / denominator[i - 1] * numerator[i - 1] + lcm / nums[i];
            numerator[i] = n1;
            denominator[i] = lcm;

            long gcd2 = gcd(denominator1[nums.length - i], nums[nums.length - 1 - i]);
            long lcm1 = (denominator1[nums.length - i] * nums[nums.length - 1 - i]) / gcd2;
            long n2 = lcm1 / denominator1[nums.length - i] * numerator1[nums.length - i] + lcm1 / nums[nums.length - 1 - i];
            numerator1[nums.length - 1 - i] = n2;
            denominator1[nums.length - 1 - i] = lcm1;




           /* prefix[i]=sum;
            sum12+=1d/nums[nums.length-1-i];
            prefix2[nums.length-1-i]=sum12;*/

        }
        /*System.out.println(Arrays.toString(numerator));
         System.out.println(Arrays.toString(denominator));*/
        int sum2 = 0;
        for (int i = 0; i < nums.length; i++) {
            //float d1=(float)(numerator[i]/(double)denominator[i]);
            sum2 += (int) (Math.floor((numerator[i] * nums[i]) / (double) denominator[i]));
            sum2 %= mod;
            if (i + 1 < nums.length) {
                // float d2=(float)(numerator1[i+1]/(double)denominator1[i+1]);
                sum2 += (int) (Math.floor((numerator1[i + 1] * nums[i]) / (double) denominator1[i + 1]));
                sum2 %= mod;
            }
        }
        return sum2;


    }

    public static boolean[] primes(int n) {
        boolean[] p = new boolean[n + 1];
        p[0] = false;
        p[1] = false;
        for (int i = 2; i <= n; i++) {
            p[i] = true;
        }

        for (int i = 2; i * i <= n; i++) {
            if (p[i]) {
                for (int j = i * i; j <= n; j += i) {
                    p[j] = false;
                }
            }

        }
        return p;
    }

    public String LargestEven(String S) {
        //  char[] ar=S.toCharArray();
        int[] count = new int[10];
        for (int i = 0; i < S.length(); i++) {
            count[S.charAt(i) - '0']++;
        }
        int num = -1;
        for (int i = 0; i <= 8; i += 2) {
            if (count[i] > 0) {
                num = i;
                break;
            }
        }
        StringBuilder ans = new StringBuilder();
        for (int i = 9; i >= 0; i--) {
            if (i != num) {
                for (int j = 1; j <= count[i]; j++) {
                    ans.append(i);
                }
            } else {
                for (int j = 1; j <= count[num] - 1; j++) {
                    ans.append(num);
                }

            }
        }
        if (num != -1 && count[num] > 0) {
            ans.append(num);
        }
        return ans.toString();
    }

}