human
Consider all binary strings of length m (1 ≤ m ≤ 60). A binary string is a string that consists of the characters 0 and 1 only. For example, 0110 is a binary string, and 012aba is not. Obviously, there are exactly 2^m such strings in total.

The string s is lexicographically smaller than the string t (both have the same length m) if in the first position i from the left in which they differ, we have s[i] < t[i]. This is exactly the way strings are compared in dictionaries and in most modern programming languages when comparing them in a standard way. For example, the string 01011 is lexicographically smaller than the string 01100, because the first two characters are the same, and the third character in the first string is less than that in the second.

We remove from this set n (1 ≤ n ≤ min(2^m-1, 100)) distinct binary strings a_1, a_2, …, a_n, each of length m. Thus, the set will have k=2^m-n strings. Sort all strings of the resulting set in lexicographical ascending order (as in the dictionary).

We number all the strings after sorting from 0 to k-1. Print the string whose index is ⌊ (k-1)/(2) ⌋ (such an element is called median), where ⌊ x ⌋ is the rounding of the number down to the nearest integer.

For example, if n=3, m=3 and a=[010, 111, 001], then after removing the strings a_i and sorting, the result will take the form: [000, 011, 100, 101, 110]. Thus, the desired median is 100.

Input

The first line contains an integer t (1 ≤ t ≤ 1000) — the number of test cases. Then, t test cases follow.

The first line of each test case contains integers n (1 ≤ n ≤ min(2^m-1, 100)) and m (1 ≤ m ≤ 60), where n is the number of strings to remove, and m is the length of binary strings. The next n lines contain a_1, a_2, …, a_n — distinct binary strings of length m.

The total length of all given binary strings in all test cases in one test does not exceed 10^5.

Output

Print t answers to the test cases. For each test case, print a string of length m — the median of the sorted sequence of remaining strings in the...
Solve the task in PYTHON.
 Can you provide a Python code to print the string whose index is ⌊ (k-1)/(2) ⌋ (such an element is called median), where ⌊ x ⌋ is the rounding of the number down to the nearest integer?
assistant
#Here is Python code to print the string whose index is ⌊ (k-1)/(2) ⌋ (such an element is called median), where ⌊ x ⌋ is the rounding of the number down to the nearest integer.

from __future__ import division, print_function
_interactive = False

def main():
    for _ in range(int(input())):
        n, m = input_as_list()
        vals = set(int(input(), 2) for _ in range(n))

        med = 2**(m-1)-1

        lo = sum((x <= med) for x in vals)
        hi = n - lo

        offset = (lo-hi+1)//2
        step = -1 if offset <= 0 else 1

        first = True
        while (med in vals) or (offset != 0):
            if med in vals:
                med += step
                if first and (offset > 0):
                    offset -= step
            elif offset != 0:
                med += step
                offset -= step
            first = False

        print(bin(med+2**m)[3:])


# Constants
INF = float('inf')
MOD = 10**9+7
alphabets = 'abcdefghijklmnopqrstuvwxyz'

# Python3 equivalent names
import os, sys, itertools
if sys.version_info[0] < 3:
    input = raw_input
    range = xrange

    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip

# print-flush in interactive problems
if _interactive:
    flush = sys.stdout.flush()
    def printf(*args, **kwargs):
        print(*args, **kwargs)
        flush()

# Debug print, only works on local machine
LOCAL = "LOCAL_" in os.environ
debug_print = (print) if LOCAL else (lambda *x, **y: None)

# Fast IO
if (not LOCAL) and (not _interactive):
    from io import BytesIO
    from atexit import register
    sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
    sys.stdout = BytesIO()
    register(lambda: os.write(1, sys.stdout.getvalue()))
    input = lambda: sys.stdin.readline().rstrip('\r\n')

# Some utility functions(Input, N-dimensional lists, ...)
def input_as_list():
    return [int(x) for x in input().split()]

def input_with_offset(o):
    return [int(x)+o for x in input().split()]

def input_as_matrix(n, m):
    return [input_as_list() for _ in range(n)]

def array_of(f, *dim):
    return [array_of(f, *dim[1:]) for _ in range(dim[0])] if dim else f()

main()