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} \dots 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 \le t \le 1000$) — the number of test cases.

The first line of each test case contains a single integer $n$ ($1 \le n \le 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:   $\mathbf{1}$ is similar to $s[1..1] = \mathbf{1}$. 

The second test case:   $\mathbf{000}$ is similar to $s[1..3] = \mathbf{000}$;  $\mathbf{000}$ is similar to $s[2..4] = \mathbf{000}$;  $\mathbf{000}$ is similar to $s[3..5] = \mathbf{000}$. 

The third test case:   $\mathbf{1}0\mathbf{10}$ is similar to $s[1..4] = \mathbf{1}1\mathbf{10}$;  $\mathbf{1}01\mathbf{0}$ is similar to $s[2..5] = \mathbf{1}10\mathbf{0}$;  $\mathbf{10}1\mathbf{0}$ is similar to $s[3..6] = \mathbf{10}0\mathbf{0}$;  $1\mathbf{0}1\mathbf{0}$ is similar to $s[4..7] = 0\mathbf{0}0\mathbf{0}$. 

The fourth test case:   $0\mathbf{0}$ is similar to $s[1..2] = 1\mathbf{0}$;  $\mathbf{0}0$ is similar to $s[2..3] = \mathbf{0}1$.

Difficulty: interview

Starter code:

Solutions:
t=int(input())
for t in range(t):
	n=int(input())
	s=input()
	a=[int(x) for x in s]
	p=a[n-1]
	print(str(p)*n)

for nt in range(int(input())):
	n = int(input())
	s = input()
	print (s[n-1]*n)

for it in range(1, int(input()) + 1):
    n = int(input())
    s = input()
    if s.count('0') > s.count('1'):
        print('0' * n)
    else:
        print('1' * n)


import math

T = int(input())

#lets = 'abcdefghijklmnopqrstuvwxyz'
#key = {lets[i]:i for i in range(26)}

for t in range(T):
  n = int(input())
  #n,m = map(int, input().split())
  #a = list(map(int,list(input().split())))
  #a = list(input())
  a = input()
  d = False
  print(a[n-1]*n)




import sys
lines = sys.stdin.read().splitlines()
lincnt = -1 

def input():
    nonlocal lincnt
    lincnt += 1
    return lines[lincnt]


for _ in range(int(input())):
    n = int(input())
    s = input()
    print(n * s[n-1])



import sys

cases = True

def c2(n):
    return n * (n+1) // 2

def get():
    return list(map(int, input().split()))

def bits(n: int):
    return list(bin(n)).count('1')

def main(test_case = False):
    n = int(input()) if test_case else 1
    for _ in range(n):
        test()

def flush():
    sys.stdout.flush()

def parr(arr):
    print(*arr, sep=' ')

def gcd(a, b):
    while b:
        if b % a == 0:
            break
        tmp = a
        a = b % a
        b = tmp
    return a

def test():
    n = int(input())
    s = input()
    c = s[n-1]
    t = c * n
    print(t)

main(cases)

for _ in range(int(input())):
  n = int(input())
  print(input()[n - 1] * n)

for _ in range (int(input())):
    n = int(input())
    s=input()
    char = s[n-1]
    ans = ''
    for i in range (n):
        ans += char
    print(ans)

import sys
sys.setrecursionlimit(10000)
# default is 1000 in python

# increase stack size as well (for hackerrank)
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, (resource.RLIM_INFINITY, resource.RLIM_INFINITY))


t = int(input())
# t = 1

for _ in range(t):
	n = int(input())
	s = input()
	ans = ""
	for i in range(n):
		ans += s[n-1]
	print(ans)


# try:
	# raise Exception
# except:
	# print("-1")


# from itertools import combinations 
# all_combs = list(combinations(range(N), r))



# from collections import OrderedDict 
# mydict = OrderedDict() 


# thenos.sort(key=lambda x: x[2], reverse=True)


# int(math.log(max(numbers)+1,2))


# 2**3 (power)


# a,t = (list(x) for x in zip(*sorted(zip(a, t))))


# to copy lists use .copy()


# pow(p, si, 1000000007) for modular exponentiation


# my_dict.pop('key', None)
# This will return my_dict[key] if key exists in the dictionary, and None otherwise.


# bin(int('010101', 2))



import math

t = int(input())

for q in range(t):
    n = int(input())
    s = input()
    for i in range(n):
        print(s[n - 1], end = '')
    print('')


for t in range(int(input())):
    n = int(input())
    s = input()
    print(s[n - 1]*n)