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.util.*;
import java.io.*;
import java.awt.Point;
public class Solution{
    public static void main(String[] args)throws IOException{
        //FastReader in=new FastReader();
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter wr=new PrintWriter(System.out);
        int t=Integer.parseInt(in.readLine());
        while(t-->0){
            int n=Integer.parseInt(in.readLine());
            String s=in.readLine();
            String ans="";
            for(int i=0;i<2*n-1;i+=2)ans=ans+s.charAt(i);
            System.out.println(ans);
        }
    }
    static Vector<Integer> printDivisors(int n){
        Vector<Integer> v = new Vector<>(); 
        for (int i=1; i<=Math.sqrt(n); i++){
            if (n%i==0){
                if (n/i == i); // check if divisors are equal 
                    //System.out.printf("%d ", i); 
                else{ 
                     //System.out.printf("%d ", i);
                    v.add(n/i); 
                } 
            } 
        } 
       return v;
    }
    static long srch(long ini,long pal,long n,long d){
        long b=1,e=n;
        while(b<=e){
            long mid=(b+e)/2;
            long val1=ini-pal-2*calsum(mid-1);
            long val2=ini-pal-2*calsum(mid);
            //System.out.println(mid+" "+calsum(mid-1)+" "+calsum(mid));
            if(val1==d && val2<d)return mid;
            else if(val1>d)b=mid+1;
            else e=mid-1;
        }
        return 1l;
    }
    static long calsum(long n){
        return (n*(n+1))/2;
    }
    static int srch(ArrayList<Pair> ar,int t){
        int b=0,e=ar.size()-1,mid=-1;
        while(b<=e){
            mid=(b+e)/2;
            //System.out.println(cnt[pos]);
            if(ar.get(mid).i<t && ar.get(mid+1).i>=t)return mid+1;
            else if(ar.get(mid).i<t)b=mid+1;
            else e=mid-1;
        }
        return -1;
    }
    static int srch(int[] a,int x){
        int b=0,e=a.length-1,mid=-1;
        while(b<=e){
            mid=(b+e)/2;
            if(a[mid]<x && a[mid+1]>x)return mid;
            else if(a[mid]>x)e=mid-1;
            else b=mid+1;
        }
        return -1;
    }
    static int primeFactors(int n){
        while (n%2==0){ 
            System.out.print(2 + " "); 
            n /= 2; 
        } 
        int cnt=0;
        for (int i = 3; i <= Math.sqrt(n); i+= 2){
            while (n%i == 0){
                cnt+=1;
                n /= i; 
            } 
        }
        if (n > 2) 
            cnt+=1;
        return cnt;
    } 
    static double distance(double x1,double x2,double y1,double y2){
        return Math.sqrt(Math.pow(x2-x1,2)+Math.pow(y2-y1,2));
    }
    static boolean[] sieve(int n){
        boolean[] ret=new boolean[n+1];
        Arrays.fill(ret,true);
        for(int i=0;i<=n;i++)ret[i]=true;
        for(int i=2;i*i<=n;i++){
            if(ret[i]==false)continue;
            for(int j=i*i;j<=n;j+=i){
                ret[j]=false;
            }
        }
        return ret;
    }
    static long calsum(long x,long y){
        y=x-y;
        y=(y*(y+1))/2;
        x=(x*(x+1))/2;
        return x-y;
    }
    static int bsrch(long[] sumdays,long x,int i){
        int b=0,e=i,mid=0;
        while(b<=e){
            mid=(b+e)/2;
            if(sumdays[i]-sumdays[mid+1]<=x && sumdays[i]-sumdays[mid]>x)return mid+1;
            else if(sumdays[i]-sumdays[mid]>x)b=mid+1;
            else e=mid-1;
        }
        return mid;
    }
    static boolean check(long[] a,long x,long k,long l){
        long e=x;
        int n=a.length;
        for(int i=0;i<n;i++){
            if(a[i]<e)e+=l;
            else if(a[i]==e)e-=k;
            else return false;
        }
        return true;
    }
    static long srch1(int h,int c,double temp){
        long b=1,e=10000000000000000l,mid=1;
        while(b<=e){
            mid=(b+e)/2;
            double t1=0.0,t2=0.0;
            if(mid%2==0){
                mid+=1;
                e+=1;
            }
            t1=(double)(((mid-1)/2)*(h+c) + h)/(double)mid;
            t2=(double)(((mid+2-1)/2)*(h+c) + h)/(double)(mid+2);
            if(t1<temp && t2>=temp)return mid;
            else if(t1<temp)b=mid+1;
            else e=mid-1;
        }
        return mid;
    }
    static long srch2(double temp,int h,int c){
        long b=1,e=10000000000000000l,mid=1;
        while(b<=e){
            mid=(b+e)/2;
            double t1=0.0,t2=0.0;
            if(mid%2==0){
                mid+=1;
                e+=1;
            }
            t1=(double)(((mid-1)/2)*(h+c) + h)/(double)mid;
            t2=(double)(((mid+2-1)/2)*(h+c) + h)/(double)(mid+2);
            if(t1<=temp && t2>=temp)return mid+2;
            else if(t1<temp)b=mid+1;
            else e=mid-1;
        }
        return mid;
    }
}
class Graph{
    public ArrayList[] adj;
    public ArrayList[] list;
    public int n;
    Graph(int n){
        this.n=n;
        adj=new ArrayList[n];
        list=new ArrayList[n];
        for(int i=0;i<n;i++)adj[i]=new ArrayList<Integer>();
        for(int i=0;i<n;i++)list[i]=new ArrayList<Integer>();
    }
    void addEdge(int i,int j){
        adj[i].add(j);
        adj[j].add(i);
    }
    Node[] bfs(Node[] nd,int start){
        boolean[] vis=new boolean[n];
        Arrays.fill(vis,false);
        Queue<Integer> q=new LinkedList<Integer>();
        q.add(start);
        while(!q.isEmpty()){
            int rem=q.remove();
            for(int i=0;i<adj[rem].size();i++){
                int x=(int)adj[rem].get(i);
                if(!vis[x]){
                    vis[x]=true;
                    nd[x].depth=nd[rem].depth+1;
                    nd[x].parent=rem;
                    q.add(x);
                }
            }
        }
        return nd;
    }
    ArrayList<Integer> bfs(int start,int[] parent,int d){
        ArrayList<Integer> ret=new ArrayList<Integer>();
        ret.add(start);
        boolean[] vis=new boolean[n];
        int[] level=new int[n];
        Arrays.fill(vis,false);
        Queue<Integer> q=new LinkedList<Integer>();
        q.add(start);
        vis[start]=true;
        while(!q.isEmpty()){
            int rem=q.remove();
            if(level[rem]>=d)continue;
            for(int i=0;i<adj[rem].size();i++){
                int x=(int)adj[rem].get(i);
                if(!vis[x] && x!=parent[start]){
                    vis[x]=true;
                    level[x]=level[rem]+1;
                    if(level[x]<=d)ret.add(x);
                    q.add(x);
                }
            }
        }
        return ret;
    }
    boolean[] dfs(boolean[] vis,int start,int p,double[] ab,double r){
        if(vis[start])return vis;
        list[p].add(start);
        vis[start]=true;
        for(int i=0;i<adj[start].size();i++){
            int x=(int)adj[start].get(i);
            if(!vis[x] && ab[x]==r)
                vis=dfs(vis,x,p,ab,r);
        }
        return vis;
    }
}
class Node{
    public int val,parent,depth,i;
    Node(int val,int depth,int parent,int i){
        this.val=val;this.depth=depth;this.parent=parent;this.i=i;
    }
}
class Box{
    public char ch;
    public int i;
    Box(char ch,int i){
        this.ch=ch;this.i=i;
    }
}
class Pair{
    public int i,j;
    Pair(int i,int j){
        this.i=i;this.j=j;
    }
}
class SegTree{
    SegTree(){}
    HashSet<Integer>[] segment;
    void build(int i, int s, int e, int[] arr){
        if (s == e){ 
            segment[i].add(arr[s]); 
            return; 
        }
        build(2 * i, s, (s + e) / 2, arr); 
        build(1 + 2 * i, 1 + (s + e) / 2, e, arr);
        segment[i].addAll(segment[2 * i]); 
        segment[i].addAll(segment[2 * i + 1]); 
    }
    HashSet<Integer> query(int node, int l,  
                                int r, int a, int b){
        HashSet<Integer> left = new HashSet<>(); 
        HashSet<Integer> right = new HashSet<>(); 
        HashSet<Integer> result = new HashSet<>();
        if (b < l || a > r) 
            return result; 
        if (a <= l && r <= b) 
            return segment[node]; 
        left = query(2 * node, l, (l + r) / 2, a, b); 
        result.addAll(left); 
  
        right = query(1 + 2 * node, 1 + (l + r) / 2, r, a, b); 
        result.addAll(right); 
        return result; 
    } 
  
    // Initialize the segment tree 
    @SuppressWarnings("unchecked") 
    void init(int n){
  
        // Get the height of the segment tree 
        int h = (int) Math.ceil(Math.log(n) / Math.log(2)); 
        h = (int) (5 * Math.pow(2, h)) - 1; 
  
        // Initialize the segment tree 
        segment = new HashSet[h]; 
        for (int i = 0; i < h; i++) 
            segment[i] = new HashSet<>(); 
    } 
  
    // Function to get the result for the 
    // subarray from arr[l] to arr[r] 
    int getDistinct(int l, int r, int n){
  
        // Query for the range set 
        HashSet<Integer> ans = query(1, 0, n - 1, l, r); 
  
        return(ans.size()); 
    }
}
class FastReader{
    public static StringTokenizer st;
    public static BufferedReader in;
    public static PrintWriter pw;
    FastReader(){
        in = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        st = new StringTokenizer("");
    }
    public static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    public static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
    public static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    public static String next() throws IOException {
        while(!st.hasMoreElements() || st == null){
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }
}