#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n, K, cnt;
char s[25][(1 << 20) + 5];
vector<int> v[25];
int dp[42000005];
int p0[25], p1[25];
int main()
{
	scanf("%d%d", &n, &K);
	for (int i = 0; i <= n; i++)
		scanf("%s", s[i]);
	for (int i = 1; i <= n; i++)
	{
		v[i].resize((i + 1) * (1 << i));
		int s = v[i].size();
		for (int j = 0; j < s; j++)
			v[i][j] = ++cnt;
	}
	for (int i = 1; i <= n; i++)
		for (int j = 0; j < (1 << i); j++)
			if (s[i][j] == '1')
				dp[v[i][j * (i + 1) + i]]++;
    for (int i = n; i >= 1; i--)
	{
		for (int S = 0; S < (1 << i); S++)
		{
			p0[0] = -1, p1[0] = -1;
			for (int j = 0; j <= i; j++)
			{
				p1[j + 1] = p1[j];
				p0[j + 1] = p0[j];
				if (S & (1 << j))
					p1[j + 1] = j;
				else
					p0[j + 1] = j;
            }
			for (int j = i; j >= 0; j--)
			{
				int u = v[i][S * (i + 1) + j];
				int f = S >> j;
				if (dp[u])
				{
					if (p0[j] != -1)
					{
						int p = ((f << 1) << p0[j]) + (S & ((1 << p0[j]) - 1));
						int l = p0[j] + 1 + i - j;
						dp[v[l][p * (l + 1) + p0[j]]] += dp[u];
					}
                    if (p1[j] != -1)
					{
						int p = ((f << 1 | 1) << p1[j]) + (S & ((1 << p1[j]) - 1));
                        int l = p1[j] + 1 + i - j;
                        dp[v[l][p * (l + 1) + p1[j]]] += dp[u];
                    }
                    if (j != 0 && j != i)
					{
						int l = i - j;
						dp[v[l][f * (l + 1)]] += dp[u];
					}
				}
			}
		}
	}
	for (int i = n; i >= 1; i--)
	{
		for (int j = 0; j < (1 << i); j++)
		{
			if (dp[v[i][j * (i + 1)]] >= K)
			{
				for (int k = i - 1; k >= 0; k--)
					putchar('0' + ((j >> k) & 1));
				putchar(10);
				return 0;
			}
		}
	}
	putchar(10);
}

### Prompt

Generate a cpp solution to the following problem:

You are given a set S of strings consisting of `0` and `1`, and an integer K.

Find the longest string that is a subsequence of K or more different strings in S. If there are multiple strings that satisfy this condition, find the lexicographically smallest such string.

Here, S is given in the format below:

* The data directly given to you is an integer N, and N+1 strings X_0,X_1,...,X_N. For every i (0\leq i\leq N), the length of X_i is 2^i.
* For every pair of two integers (i,j) (0\leq i\leq N,0\leq j\leq 2^i-1), the j-th character of X_i is `1` if and only if the binary representation of j with i digits (possibly with leading zeros) belongs to S. Here, the first and last characters in X_i are called the 0-th and (2^i-1)-th characters, respectively.
* S does not contain a string with length N+1 or more.



Here, a string A is a subsequence of another string B when there exists a sequence of integers t_1 < ... < t_{|A|} such that, for every i (1\leq i\leq |A|), the i-th character of A and the t_i-th character of B is equal.

Constraints

* 0 \leq N \leq 20
* X_i(0\leq i\leq N) is a string of length 2^i consisting of `0` and `1`.
* 1 \leq K \leq |S|
* K is an integer.

Input

Input is given from Standard Input in the following format:


N K
X_0
:
X_N


Output

Print the lexicographically smallest string among the longest strings that are subsequences of K or more different strings in S.

Examples

Input

3 4
1
01
1011
01001110


Output

10


Input

4 6
1
01
1011
10111010
1101110011111101


Output

100


Input

2 5
0
11
1111


Output

### Response

```cpp
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n, K, cnt;
char s[25][(1 << 20) + 5];
vector<int> v[25];
int dp[42000005];
int p0[25], p1[25];
int main()
{
	scanf("%d%d", &n, &K);
	for (int i = 0; i <= n; i++)
		scanf("%s", s[i]);
	for (int i = 1; i <= n; i++)
	{
		v[i].resize((i + 1) * (1 << i));
		int s = v[i].size();
		for (int j = 0; j < s; j++)
			v[i][j] = ++cnt;
	}
	for (int i = 1; i <= n; i++)
		for (int j = 0; j < (1 << i); j++)
			if (s[i][j] == '1')
				dp[v[i][j * (i + 1) + i]]++;
    for (int i = n; i >= 1; i--)
	{
		for (int S = 0; S < (1 << i); S++)
		{
			p0[0] = -1, p1[0] = -1;
			for (int j = 0; j <= i; j++)
			{
				p1[j + 1] = p1[j];
				p0[j + 1] = p0[j];
				if (S & (1 << j))
					p1[j + 1] = j;
				else
					p0[j + 1] = j;
            }
			for (int j = i; j >= 0; j--)
			{
				int u = v[i][S * (i + 1) + j];
				int f = S >> j;
				if (dp[u])
				{
					if (p0[j] != -1)
					{
						int p = ((f << 1) << p0[j]) + (S & ((1 << p0[j]) - 1));
						int l = p0[j] + 1 + i - j;
						dp[v[l][p * (l + 1) + p0[j]]] += dp[u];
					}
                    if (p1[j] != -1)
					{
						int p = ((f << 1 | 1) << p1[j]) + (S & ((1 << p1[j]) - 1));
                        int l = p1[j] + 1 + i - j;
                        dp[v[l][p * (l + 1) + p1[j]]] += dp[u];
                    }
                    if (j != 0 && j != i)
					{
						int l = i - j;
						dp[v[l][f * (l + 1)]] += dp[u];
					}
				}
			}
		}
	}
	for (int i = n; i >= 1; i--)
	{
		for (int j = 0; j < (1 << i); j++)
		{
			if (dp[v[i][j * (i + 1)]] >= K)
			{
				for (int k = i - 1; k >= 0; k--)
					putchar('0' + ((j >> k) & 1));
				putchar(10);
				return 0;
			}
		}
	}
	putchar(10);
}

```