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.io.*; 
import java.util.*; 
import java.math.*; 

public class Main { 
	static void print(int a){
		System.out.println(a);

	}
	static void print(long[] arr){
		StringBuffer s = new StringBuffer(); 
		for (int i = 0; i < arr.length; i++) 
			s.append(arr[i] + " "); 
		System.out.println(s);
	}
	static void dfs(ArrayList<ArrayList<Integer>> graph,int u,boolean[] visited,int[] sum){
		visited[u]=true;
		sum[u]=1;
		for(int i=0;i<graph.get(u).size();i++){
			int child=graph.get(u).get(i);
			if(visited[child]==false){
				dfs(graph,child,visited,sum);
				sum[u]+=sum[child];
			}
		}
	}
	static long power(long x, long y, long m)
    {
        if (y == 0)
            return 1;
 
        long p = power(x, y / 2, m) % m;
        p = (p * p) % m;
 
        if (y % 2 == 0)
            return p;
        else
            return (x * p) % m;
    } 

	public static void main(String[] args) throws IOException 
	{ 
		FastScanner f = new FastScanner(); 
		int t=f.nextInt();
//		int t=1;
		while(t-->0){
			 int n=f.nextInt();
			 String s=f.next();
			 int num1=0;
			 for(int i=0;i<2*n-1;i++) {
				 if(s.charAt(i)=='1') {
					 num1++;
				 }
			 }
			 if(num1>=n) {
				 for(int i=0;i<n;i++) {
					 System.out.print('1');
				 }
				 System.out.println();
			 }
			 else {
				 for(int i=0;i<n;i++) {
					 System.out.print('0');
				 }
				 System.out.println();
			 }
		}


		
	} 


	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}
		
		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
		double nextDouble() {
			return Double.parseDouble(next());
		}
		double[] readLongArray(int n) {
			double[] a=new double[n];
			for (int i=0; i<n; i++) a[i]=nextDouble();
			return a;
		}
	}
} 
