A binary string is a string where each character is either 0 or 1. Two binary strings a and b of equal length are similar, if they have the same character in some position (there exists an integer i such that a_i = b_i). For example:

  * 10010 and 01111 are similar (they have the same character in position 4); 
  * 10010 and 11111 are similar; 
  * 111 and 111 are similar; 
  * 0110 and 1001 are not similar. 



You are given an integer n and a binary string s consisting of 2n-1 characters. Let's denote s[l..r] as the contiguous substring of s starting with l-th character and ending with r-th character (in other words, s[l..r] = s_l s_{l + 1} s_{l + 2} ... s_r).

You have to construct a binary string w of length n which is similar to all of the following strings: s[1..n], s[2..n+1], s[3..n+2], ..., s[n..2n-1].

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.

The first line of each test case contains a single integer n (1 ≤ n ≤ 50).

The second line of each test case contains the binary string s of length 2n - 1. Each character s_i is either 0 or 1.

Output

For each test case, print the corresponding binary string w of length n. If there are multiple such strings — print any of them. It can be shown that at least one string w meeting the constraints always exists.

Example

Input


4
1
1
3
00000
4
1110000
2
101


Output


1
000
1010
00

Note

The explanation of the sample case (equal characters in equal positions are bold):

The first test case: 

  * 1 is similar to s[1..1] = 1. 



The second test case: 

  * 000 is similar to s[1..3] = 000; 
  * 000 is similar to s[2..4] = 000; 
  * 000 is similar to s[3..5] = 000. 



The third test case: 

  * 1010 is similar to s[1..4] = 1110; 
  * 1010 is similar to s[2..5] = 1100; 
  * 1010 is similar to s[3..6] = 1000; 
  * 1010 is similar to s[4..7] = 0000. 



The fourth test case: 

  * 00 is similar to s[1..2] = 10; 
  * 00 is similar to s[2..3] = 01. 

import java.awt.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
import java.util.List;

/**
 * Codeforces
 * 
 * 
 */
public class Codeforcess {

    public static boolean has1inbetween(String s, int i, int j) {
        boolean ans = true;
        char ch[] = s.toCharArray();

        for (int b = i + 1; b < j && b < s.length() && i < ch.length && j < ch.length; b++) {
            if (ch[i] == '1') {
                ans = false;
            }
        }
        return ans;
    }

    public static int segregate(int arr[], int size) {
        int j = 0, i;
        for (i = 0; i < size; i++) {
            if (arr[i] <= 0) {
                int temp;
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                // increment count of non-positive
                // integers
                j++;
            }
        }

        return j;
    }

    public static long lowComMultiple(long a, long b) {
        long min = a * b;
        long start = Math.min(a, b);
        long ans = -1;
        for (int i = (int) start; i <= min; i++) {
            if (i % a == 0 && i % b == 0) {
                ans = i;
                break;
            }
        }
        return ans;
    }

    public static int solution(int[] A) {
        int n = A.length;

        // To mark the occurrence of elements
        boolean[] present = new boolean[n + 1];

        // Mark the occurrences
        for (int i = 0; i < n; i++) {

            if (A[i] > 0 && A[i] <= n)
                present[A[i]] = true;
        }

        // Find the first element which didn't
        // appear in the original array
        for (int i = 1; i <= n; i++)
            if (!present[i])
                return i;

        return n + 1;
    }

    public static ArrayList<Long> digit(long num) {
        long dig = 0;
        // long length = 0;
        ArrayList<Long> digi = new ArrayList<>();
        while (num > 0) {
            dig = num % 10;
            digi.add(dig);
            num = num / 10;

        }
        // return dig; //System.out.printf("%d", +revnum);

        return digi;
    }

    static int[] shuffle(int a[], int n) {
        for (int i = 0; i < n; i++) {

            // getting the random index
            int t = (int) Math.random() * a.length;

            // and swapping values a random index
            // with the current index
            int x = a[t];
            a[t] = a[i];
            a[i] = x;
        }
        return a;
    }

    public static long addDigits(long num) {
        long digit = 0;
        // long sum = 0;
        long dig = -1;

        while (num != 0) {
            digit = num % 10;
            dig = digit;
            num = num / 10;
            break;
        }
        return dig;
    }

    public static int addDigit(long num) {
        long digit = 0;
        // long sum = 0;
        int count = 0;

        while (num != 0) {
            digit = num % 10;
            count++;
            num = num / 10;

        }
        return count;
    }

    public static class Pair<A, B> {
        private A first;
        private B second;

        public Pair(A first, B second) {
            this.first = first;
            this.second = second;
        }

        public A getFirst() {
            return first;
        }

        public B getSecond() {
            return second;
        }

        public void setFirst(A first) {
            this.first = first;
        }

        public void setSecond(B second) {
            this.second = second;
        }
    }

    static void findPair(int values[], int n, Pair<Integer, Integer> ans) {
        // Pair<Integer, Integer> ans = new Pair<Integer,Integer>(0, 0);
        int size = values.length;
        int i = 0, j = 1;
        int minLen = Integer.MAX_VALUE;
        int in = -1;
        int jn = -1;
        while (i < size && j < size) {

            if (i != j && values[j] - values[i] == n) {

                if (j - i < minLen) {
                    in = i;
                    jn = j;
                }
                break;
                // System.out.print("Pair Found: " + "( " + values[i] + ", " + values[j] + "
                // )");
                // return "1";
            } else if (values[j] - values[i] < n)
                j++;
            else
                i++;
        }

        if (in == -1 && jn == -1) {
            ans.setFirst(-1);
            ans.setSecond(-1);
        } else {
            ans.setFirst(in + 1);
            ans.setSecond(jn + 1);
        }

        // return ans;
    }

    public static String findMinDays(int[] values, int[] profit) {

        StringBuilder str = new StringBuilder();
        ArrayList<Pair<Integer, Integer>> ans = new ArrayList<>();
        Pair<Integer, Integer> p = new Pair<Integer, Integer>(0, 0);
        for (int i = 0; i < profit.length; i++) {
            findPair(values, profit[i], p);
            ans.add(p);
        }

        for (int i = 0; i < ans.size(); i++) {
            if (ans.get(i).getFirst() != -1 || ans.get(i).getSecond() != -1) {
                str.append(ans.get(i).getFirst());
                str.append(" ");
                str.append(ans.get(i).getSecond() + ",");
            } else {
                str.append(-1 + ",");
            }
        }

        String s;
        str.setCharAt(str.length() - 1, ' ');
        s = str.toString();
        return s;

    }

    public static long fact(long n) {
        BigInteger res = new BigInteger("1");
        for (long i = 2; i <= n; i++)
            res = res.multiply(BigInteger.valueOf(i));
        return res.longValue();
    }

    public static long nCr(long n, long r) {
        long den = (fact(r) * fact(n - r));
        long num = fact(n);
        if (den <= 0 || num < 0)
            return 1;
        else
            return num / den;

    }

    public static int[] seq(int n, int x, int y) {
        int best = Integer.MAX_VALUE;
        int[] bestArr = new int[n];
        for (int start = 1; start <= 50; start++) {
            for (int diff = 1; diff <= 50; diff++) {
                boolean X = false, Y = false;
                int[] a = ap(n, start, diff);
                for (int i = 0; i < n; i++) {
                    if (a[i] == x)
                        X = true;
                    if (a[i] == y)
                        Y = true;

                }
                if (X && Y && a[n - 1] < best) {
                    best = a[n - 1];
                    bestArr = a;
                }
            }
        }
        return bestArr;
    }

    public static int[] ap(int n, int start, int diff) {
        int arr[] = new int[n];
        arr[0] = start;
        for (int i = 1; i < n; i++) {
            arr[i] = arr[i - 1] + diff;
        }
        return arr;
    }

    public static int cntSame(String s) {
        int ans = 0;
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i - 1) == s.charAt(i)) {
                ans++;

            }
        }
        if (ans % 2 == 0)
            ans = ans / 2;

        return ans;
    }

    public void dump() {
        // Scanner sc = new Scanner(System.in);
        // int t = sc.nextInt();
        // while (t-- > 0) {
        // int n = sc.nextInt();
        // int m = sc.nextInt();

        // // int mArr[][] = new int[n][m];
        // ArrayList<ArrayList<Integer>> mArr = new ArrayList<>();
        // ArrayList<Integer> temp = new ArrayList<>();
        // for (int i = 0; i < n; i++) {
        // temp = new ArrayList<>();
        // for (int j = 0; j < m; j++) {
        // temp.add(sc.nextInt());
        // }
        // mArr.add(i, temp);
        // }
        // ArrayList<ArrayList<Integer>> nArr = new ArrayList<>();
        // ArrayList<Integer> temp1 = new ArrayList<>();
        // for (int i = 0; i < m; i++) {
        // temp1 = new ArrayList<>();
        // for (int j = 0; j < n; j++) {
        // temp1.add(sc.nextInt());
        // }
        // nArr.add(i, temp1);
        // }
        // ArrayList<Integer> rowOrder = new ArrayList<>();
        // for (int i = 0; i < m; i++) {
        // rowOrder.add(nArr.get(0).get(i));
        // }

        // ArrayList<ArrayList<Integer>> rowCol = new ArrayList<>();
        // int p = 0;
        // for (int i = 0; i < n; i++) {
        // int rowOrdElem = rowOrder.get(p);
        // if (nArr.get(i).contains(rowOrdElem)) {
        // rowCol.add(nArr.get(i));
        // p++;
        // } else {
        // int row = 0;
        // for (int k = 0; k < nArr.get(i).size(); k++) {
        // for (int l = 0; l < rowOrder.size(); l++) {
        // if (nArr.get(row).get(k) == rowOrder.get(l)) {
        // rowCol.add(l, nArr.get(row));
        // row++;
        // } else {
        // row++;
        // }
        // }
        // }
        // }

        // }
        // for (int i = 0; i < rowCol.size(); i++) {
        // for (int j = 0; j < rowCol.get(i).size(); j++) {
        // System.out.print(rowCol.get(i).get(j) + " ");
        // }
        // System.out.println();
        // }

        // }

    }

    public static void main(String[] args) {

        try {
            Scanner sc = new Scanner(System.in);
            int t = sc.nextInt();
            while (t-- > 0) {
                int n = sc.nextInt();
                sc.nextLine();
                String s = sc.next();
                StringBuilder ans = new StringBuilder();
                for (int i = 0; i < s.length(); i += 2) {
                    ans.append(s.charAt(i));
                }
                System.out.println(ans.toString());
            }
        } catch (Exception e) {
            System.out.println(e);
        }

    }

}