Let w be a positive integer and p be a character string with a length of 22w + 1. (w, p) -A cellular automaton is as follows.

* An infinite number of cells that can take the state of 0 or 1 are lined up in one dimension.
* At time 0, Sunuke can choose any finite number of squares and set the state to 1. The remaining cells are 0.
* The state f (t, x) of cell x at time t (> 0) is determined by f (t − 1, x − w), ..., f (t − 1, x + w) as follows. Determined:
\ begin {eqnarray} f (t, x) = p [\ sum ^ w_ {i = -w} 2 ^ {w + i} f (t − 1, x + i)] \; \; \; \; \; \; \; \; \; \; (1) \ end {eqnarray}



Sunuke likes cellular automata so that the number of 1s does not change from the initial state no matter how the initial state is selected at time 0. Given the integer w and the string s, find the smallest p that is greater than or equal to s in lexicographical order (w, p) -cell automaton is preferred by you.

Constraints

* 1 ≤ w ≤ 3
* | s | = 22w + 1
* The only characters that appear in s are '0' and '1'

Input


w
s


Output

Output the minimum p that satisfies the condition. If there is no such thing, output "no".

Examples

Input

1
00011000


Output

00011101


Input

1
11111111


Output

no
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };

ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;

ll d[256];

bool bellman_ford(int n, vector<edge>& E, int s, ll d[]) {
	fill(d, d + n, LLONG_MAX); d[s] = 0;
	for (int i = 0; i < n; i++) {
		bool updated = false;
		for (int j = 0; j < E.size(); j++) {
			edge e = E[j];
			if (d[e.u] < LLONG_MAX && d[e.v] > d[e.u] + e.w) {
				d[e.v] = d[e.u] + e.w;
				updated = true;
			}
		}
		if (!updated) return true;
	}
	return false;
}

string check(int N, string s) {
	vector<edge> E;
	for (int u = 0; u < N; u++) {
		E.push_back(edge{u, N + u, 0});
		E.push_back(edge{N + u, u, 1});
		int v;
		v = u * 2 % N;
		E.push_back(edge{N + u, v, 0});
		E.push_back(edge{v, N + u, 0});
		v = (u * 2 + 1) % N;
		E.push_back(edge{N + u, v, 1});
		E.push_back(edge{v, N + u, -1});
	}
	for (int u = 0; u < N; u++) {
		if (s[u] == '0')
			E.push_back(edge{N + u, u, 0});
		if (s[u] == '1')
			E.push_back(edge{u, N + u, -1});
	}
	if (!bellman_ford(N * 2, E, 0, d)) return "";
	string t(N, ' ');
	for (int u = 0; u < N; u++)
		if (d[u] == d[N + u]) t[u] = '0';
		else t[u] = '1';
	return t;
}

int main() {
	int w; cin >> w;
	string s; cin >> s;
	int N = s.length();
	string t = check(N, s);
	if (t != "") {
		cout << t << endl;
		return 0;
	}
	for (int i = N - 1; i >= 0; i--) {
		if (s[i] == '0') {
			s[i] = '1';
			string t = check(N, s);
			if (t != "") {
				cout << t << endl;
				return 0;
			}
		}
		s[i] = '?';
	}
	cout << "no" << endl;
}