QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#294275#7788. Rook DetectionCrysflyAC ✓1259ms5376kbC++145.4kb2023-12-30 11:11:142023-12-30 11:11:15

Judging History

你现在查看的是最新测评结果

  • [2023-12-30 11:11:15]
  • 评测
  • 测评结果:AC
  • 用时:1259ms
  • 内存:5376kb
  • [2023-12-30 11:11:14]
  • 提交

answer

// what is matter? never mind. 
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx,avx,avx2") 
#include<bits/stdc++.h>
#define For(i,a,b) for(int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(int i=(a);i>=(b);--i)
#define ll long long
//#define int long long
#define ull unsigned long long
using namespace std;
inline int read()
{
    char c=getchar();int x=0;bool f=0;
    for(;!isdigit(c);c=getchar())f^=!(c^45);
    for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+(c^48);
    if(f)x=-x;return x;
}

#define fi first
#define se second
#define pb push_back
#define mkp make_pair
typedef pair<int,int>pii;
typedef vector<int>vi;

#define fi first
#define se second
#define pb push_back
#define mkp make_pair
typedef pair<int,int>pii;
typedef vector<int>vi;

#define maxn 500005
#define inf 0x3f3f3f3f

bool isr,isi;
int n,lg,qcnt;
bool a[505][505],res[505][505],b[505][505];

void ask(){
	++qcnt;
	cout<<"?"<<endl;
	For(i,1,n){
		For(j,1,n)cout<<a[i][j];
		cout<<endl;
	}
	int x;cin>>x;
	if(x==1){
		if(!isr){
			while(1);
		}else{
			exit(233);
		}
	}
	For(i,1,n){
		string s;cin>>s;
		For(j,1,n)b[i][j]=(s[j-1]&1),a[i][j]=0;
	}
}
bool hav[505];
bool don[505];

vi buc[505];

void answer(){
	int sum=0;
	For(i,1,n)For(j,1,n)sum+=res[i][j];
	if(sum<n){
		if(isi){
			while(1);
		}
		else assert(0);
	}
	
	cout<<"!"<<endl;
	For(i,1,n){
		For(j,1,n)cout<<res[i][j];
		cout<<endl;
	}
	
	
	int x;cin>>x;
	
//	assert(x==0);
}

vi split(vi o,int l,int r){
	vi p;
	For(i,l,r) p.pb(o[i]);
	return p;
}

void rows(int x){
	isr=1;
	For(i,1,n){
		buc[i].clear();
		For(j,1,n)if(j!=x)buc[i].pb(j);
	//	cout<<"sz "<<buc[i].size()<<"\n";
	}
	while(1){
		bool ok=1;
		For(i,1,n){
			if(!buc[i].size())continue;
			if(buc[i].size()==1){
				res[buc[i][0]][i]=1;
				continue;
			}
			ok=0;
		}
		if(ok){
			answer();
			break;
		}
		For(i,1,n){
			if(buc[i].size()>1){
				int mid=(buc[i].size()-1)>>1;
				a[x][i]=1;
				For(j,mid+1,buc[i].size()-1) a[buc[i][j]][i]=1;
			}
		}
		ask();
		For(i,1,n){
			if(buc[i].size()>1){
				int mid=(buc[i].size()-1)>>1;
				if(b[x][i]) buc[i]=split(buc[i],mid+1,buc[i].size()-1);
				else buc[i]=split(buc[i],0,mid);
			}
		}
	}
}

bool use[505];

void work(int ID)
{
	cin>>n;
	lg=0;qcnt=0;isi=0;
	while((1<<lg)<n)++lg;
	isr=0;
	For(i,1,n)For(j,1,n)res[i][j]=a[i][j]=0;
	For(i,1,n)hav[i]=use[i]=don[i]=0;
//	if(ID==5){
//		For(i,1,n){
//			a[3][i]=1;
//			ask();
//		}exit(0);
//	}
		
	/*
	ABBB
	AABB
	ABAB
	ABBA
	*/
	For(i,1,n)For(j,1,n)if(i==j||j==1)a[i][j]=1;
	a[1][1]=0;
	
	ask();
	if(!b[1][1]){
		rows(1);
		return;
	}
	
	int pos=0;
	For(i,2,n)
		if(!b[i][i])pos=i;
		else hav[i]=1,a[i][1]=1;
	
	bool spe=0;
	if(!pos){
		/*
		BAAA
		ABBB
		ABBB
		ABBB
		*/
		For(i,2,n) a[1][i]=1;
		ask();
		if(b[1][1])res[1][1]=hav[1]=1;
		
		if(hav[1]){
			For(i,2,n) a[i][i]=1;
			ask();
			For(i,2,n) {
				if(b[i][i])res[i][i]=1;
				else res[i][1]=1;
			}
			answer();
			return;
		}
		else spe=1;
	}else{
		a[pos][pos]=a[1][1]=a[1][pos]=1;
		ask();
		For(i,2,n){
			if(!hav[i] && !b[i][1]){
				rows(i);
				return;
			}
		}
		if(b[pos][pos]) res[1][pos]=hav[1]=1;
		else if(b[1][pos]) res[1][1]=hav[1]=1;
		// else : res[1][1]=0
	}
	
	vi o;
	For(i,2,n) if(hav[i]) o.pb(i);
	For(i,2,n) if(!hav[i]) o.pb(i);
	
//	cout<<"o: ";for(auto x:o)cout<<x<<" "; cout<<"\n";
	For(i,1,n) 
		if(!hav[i]) buc[i]=o; else buc[i].clear();
	
	int now=o.size();
	int nw=now;
	For(_,1,lg) nw=(nw+1)>>1;
	assert(nw==1);
	
	while(1){
		bool ok=1;
		int mxs=0;
		For(i,1,n){
			mxs=max(mxs,(int)buc[i].size());
			if(!buc[i].size())continue;
			if(buc[i].size()==1){
				res[i][buc[i][0]]=1;
				continue;
			}
			ok=0;
		}
		if(spe && mxs==2)
		{
			// res[1][1] empty
			int u=buc[1][0],v=buc[1][1];
			if(!don[u] && !don[v]){
				isi=1;
				a[1][1]=1,a[1][u]=1,a[u][1]=1;
				a[v][v]=1;
				ask();
				if(b[v][v]) res[v][v]=1;
				else res[v][1]=1;
				if(b[1][u]) res[1][u]=1;
				else res[1][v]=1;
				if(b[u][1]) res[u][1]=1;
				else res[u][u]=1;
				answer();
				return;
			}
		}
		if(ok){
			bool ok2=1;
			For(i,2,n)
				if(hav[i] && (!res[i][1]&&!res[i][i])) ok2=0;
			if(!ok2){
				For(i,2,n) 
					if(hav[i]) a[i][i]=1;
				ask();
				For(i,2,n)
					if(b[i][i]) res[i][i]=1;
					else res[i][1]=1;
			}
			answer();
			break;
		}
		For(i,1,n) use[i]=0;
		For(i,1,n)
			if(buc[i].size()>1){
				int mid=(buc[i].size()-1)>>1;
				a[i][1]=1;
			//	For(j,mid+1,buc[i].size()-1)cout<<"VIS "<<buc[i][j]<<"\n";
				For(j,mid+1,buc[i].size()-1) a[i][buc[i][j]]=1,use[buc[i][j]]=1;
			}
		For(i,2,n)
			if(hav[i] && !use[i]) a[i][i]=1;
		assert(mxs<=now);
		if(qcnt+1<=lg+2){
			
		}
	//	assert(qcnt+1<=lg+2);
		ask();
		For(i,1,n){
			if(buc[i].size()>1){
				int mid=(buc[i].size()-1)>>1;
				if(b[i][1]) buc[i]=split(buc[i],mid+1,buc[i].size()-1);
				else buc[i]=split(buc[i],0,mid);
			}
		}
		For(i,2,n)
			if(hav[i] && !use[i]){
				if(b[i][i]) res[i][i]=1;
				else res[i][1]=1;
				don[i]=1;
			}
		int mxs2=0;
		For(i,1,n) mxs2=max(mxs2,(int)buc[i].size());
		assert(mxs2<=(mxs+1)/2);
		now=(now+1)/2;
	}
}

signed main()
{
	int T;cin>>T;
	For(_,1,T)work(_);
	return 0;
}
/*
010
111
110

0
100
100
101

1
111
111
101


111
010
010
*/

这程序好像有点Bug,我给组数据试试?

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 1ms
memory: 3460kb

input:

1
3
0
111
101
111
0
111
111
101
0
111
001
110
0

output:

?
000
110
101
?
110
010
100
?
000
110
001
!
010
001
100

result:

ok correct! (1 test case)

Test #2:

score: 0
Accepted
time: 81ms
memory: 3496kb

input:

9898
3
0
111
110
111
0
111
111
111
0
111
111
111
0
3
0
111
111
111
0
011
111
111
0
111
111
111
0
3
0
111
111
111
0
011
111
111
0
001
011
111
0
3
0
111
101
111
0
101
101
111
0
001
001
110
0
3
0
111
111
010
0
111
111
111
0
111
111
010
0
3
0
111
111
111
0
011
111
111
0
111
011
110
0
3
0
111
111
111
0
1...

output:

?
000
110
101
?
011
100
100
?
000
010
001
!
100
010
001
?
000
110
101
?
011
100
100
?
110
100
001
!
010
100
001
?
000
110
101
?
011
100
100
?
110
100
001
!
001
010
001
?
000
110
101
?
110
010
100
?
110
110
001
!
001
001
100
?
000
110
101
?
101
100
001
?
000
010
101
!
001
010
010
?
000
110
101
?
011
...

result:

ok correct! (9898 test cases)

Test #3:

score: 0
Accepted
time: 104ms
memory: 3472kb

input:

10000
4
0
1111
1011
1111
1111
0
1111
1111
1111
1111
0
1111
0011
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
1110
0
1111
1111
1111
1111
0
1111
1111
1101
0110
0
1111
1111
1111
0101
0
4
0
1111
1011
1111
1111
0
1111
1111
1111
1111
0
1111
0011
1111
1111
0
1111
0110
1111
1111
0
4
0
1111
1011
1111...

output:

?
0000
1100
1010
1001
?
1100
0100
1000
1000
?
0000
1100
0010
0001
?
0000
1001
0010
0000
!
0100
0001
0010
0001
?
0000
1100
1010
1001
?
1001
1000
1000
0001
?
0000
0100
0010
1001
?
0000
0100
0000
1010
!
0001
0100
1000
0100
?
0000
1100
1010
1001
?
1100
0100
1000
1000
?
0000
1100
0010
0001
?
0000
1001
00...

result:

ok correct! (10000 test cases)

Test #4:

score: 0
Accepted
time: 135ms
memory: 3456kb

input:

10000
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1011
1111
1111
0
1111
1011
1111
1111
0
1111
0011
1111
1110
0
1111
0110
1111
1111
0
4
0
1111
1111
1111
1111
0
0111
1101
1101
1111
0
1111
1011
1101
1111
0
1111
1011
1101
1111
0
4
0
1111
1111
1111...

output:

?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
1001
0100
0010
0000
?
0000
0100
0010
0001
!
0001
0100
0010
0001
?
0000
1100
1010
1001
?
1100
0100
1000
1000
?
0000
1100
0010
0001
?
0000
1001
0010
0000
!
1000
0010
0010
1000
?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
1001
0100
0010
0000
?
0000
0100
00...

result:

ok correct! (10000 test cases)

Test #5:

score: 0
Accepted
time: 158ms
memory: 3456kb

input:

10000
4
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1011
1111
1111
0
4
0
1111
1111
1101
1111
0
1111
1111
1111
1111
0
1111
1011
0101
1110
0
1111
1011
1111
1111
0
4
0
1111
1111
1111
1101
0
1111
1111
1111
1111
0
1111
1011
1111
1110
0
4
0
1111
1101
1011
1001
0
0111
1111
1111
1111
0
1001
1111
1111...

output:

?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
0000
0100
0010
0001
!
1000
1000
0010
0001
?
0000
1100
1010
1001
?
1010
1000
0010
1000
?
0000
0100
1010
0001
?
0000
0100
1001
0000
!
0010
1000
0001
1000
?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
0000
0100
0010
0001
!
1000
1000
0010
1000
?
0000
1100
10...

result:

ok correct! (10000 test cases)

Test #6:

score: 0
Accepted
time: 130ms
memory: 3464kb

input:

10000
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
0110
1111
1101
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
1110
0
1111
1111
1111
1111
0
1111
1011
1111
0110
0
1111
1011
1111
1111
0
4
0
1111
1111
1111
1110
0
1111
1111
1111
1111
0
1111
1111
1111
0110
0
1111
1111
1111
1111
0
4
0
1111
1111
1111...

output:

?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
1001
0100
0010
0000
?
1010
0100
0000
0001
!
0010
0100
1000
0001
?
0000
1100
1010
1001
?
1001
1000
1000
0001
?
0000
0100
0010
1001
?
0000
0100
0000
1010
!
0001
1000
0010
0010
?
0000
1100
1010
1001
?
1001
1000
1000
0001
?
0000
0100
0010
1001
?
0000
0100
00...

result:

ok correct! (10000 test cases)

Test #7:

score: 0
Accepted
time: 934ms
memory: 4552kb

input:

7368
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
0110
1011
1111
1111
0
0101
1011
1111
1111
0
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
...

output:

?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
1001
0100
0010
0000
?
0000
0100
0010
0001
!
0001
0100
0010
0001
?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
1001
0100
0010
0000
?
1010
0100
0000
0001
!
0100
1000
0010
0001
?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
1001
0100
0010
0000
?
0000
0100
00...

result:

ok correct! (7368 test cases)

Test #8:

score: 0
Accepted
time: 734ms
memory: 5144kb

input:

10000
9
0
111111111
101111111
110111111
111111111
111101111
111110111
111111111
111111111
111111111
0
111110111
111111111
111111111
111111111
111111111
111110111
111111111
111111111
111111111
0
111111110
111111110
010110111
111111111
010110111
010110111
111111011
111111101
111111111
0
011110111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100001000
000000000
000000000
100000000
000000000
000001000
100000000
100000000
100000000
?
111011000
111011000
111011000
000100000
111011000
111011000
000000100
000000010
000000001
?
100011000
100011000
10...

result:

ok correct! (10000 test cases)

Test #9:

score: 0
Accepted
time: 691ms
memory: 4492kb

input:

10000
5
0
11111
10111
11111
11111
11111
0
11111
10111
11111
11111
11111
0
11111
00110
11011
11111
11111
0
11111
11111
11011
11111
11110
0
8
0
11111111
10111111
11111111
11111111
11110111
11111011
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111011
11111111
11111111
0
11111111
0...

output:

?
00000
11000
10100
10010
10001
?
11000
01000
10000
10000
10000
?
00000
11001
00100
00010
00000
?
00000
10010
00100
00000
00001
!
10000
00010
10000
00010
10000
?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000100
00000000
10000000
10000000
00000000
00000100
10000000
1...

result:

ok correct! (10000 test cases)

Test #10:

score: 0
Accepted
time: 586ms
memory: 4436kb

input:

10000
9
0
111111111
111111111
111111111
111011111
111101111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111101111
111111111
111111111
111111111
111111111
0
111111111
101111111
110111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
1011...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100010000
100000000
100000000
000000000
000010000
100000000
100000000
100000000
100000000
?
000000000
010000000
001000000
100110011
100110011
000001000
000000100
000000000
000000000
?
000000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #11:

score: 0
Accepted
time: 717ms
memory: 4364kb

input:

10000
4
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1011
1111
1111
0
6
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
6
0
111111
111111
111111
111111
111101
111111
0
111111
111111
111111
111111
111111
11111...

output:

?
0000
1100
1010
1001
?
0111
1000
1000
1000
?
0000
0100
0010
0001
!
1000
1000
0010
0001
?
000000
110000
101000
100100
100010
100001
?
011111
100000
100000
100000
100000
100000
?
000000
010000
001000
000100
000010
000001
!
100000
010000
001000
000100
000010
000001
?
000000
110000
101000
100100
100010...

result:

ok correct! (10000 test cases)

Test #12:

score: 0
Accepted
time: 360ms
memory: 4192kb

input:

10000
6
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
9
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
11...

output:

?
000000
110000
101000
100100
100010
100001
?
011111
100000
100000
100000
100000
100000
?
000000
010000
001000
000100
000010
000001
!
100000
010000
001000
000100
000010
000001
?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
011111111
100000000
100000000
...

result:

ok correct! (10000 test cases)

Test #13:

score: 0
Accepted
time: 469ms
memory: 4956kb

input:

10000
6
0
111111
101111
110111
111011
100010
111110
0
100011
111111
111111
111111
100010
111110
0
111111
011010
011010
011010
111101
011010
0
111111
010111
010111
010111
111101
010111
0
111111
001111
001111
001111
111101
001111
0
8
0
11111111
11000110
10100110
11101111
10001110
11111011
10000110
111...

output:

?
000000
110000
101000
100100
100010
100001
?
100001
000000
000000
000000
100000
000001
?
000000
100101
100101
100101
000010
100101
?
000000
101000
101000
101000
000010
101000
?
000000
110000
110000
110000
000010
110000
!
100000
000010
000010
000010
100000
000010
?
00000000
11000000
10100000
1001000...

result:

ok correct! (10000 test cases)

Test #14:

score: 0
Accepted
time: 489ms
memory: 5044kb

input:

10000
6
0
111111
001111
010111
011011
011101
011110
0
111111
011111
111111
011111
011111
011110
0
111111
000000
111111
111111
000000
000000
0
111111
000000
111111
000000
111111
111111
0
111111
000101
111111
111010
111010
111010
0
9
0
011101111
101101111
110101111
111001111
111111111
111100111
111101...

output:

?
000000
110000
101000
100100
100010
100001
?
100001
000000
000000
000000
000000
000001
?
000000
111111
000000
000000
111111
111111
?
000000
111111
000000
111111
000000
000000
?
000000
111111
111111
000000
000000
000000
!
111010
000000
000101
000000
000000
000000
?
000000000
110000000
101000000
1001...

result:

ok correct! (10000 test cases)

Test #15:

score: 0
Accepted
time: 601ms
memory: 4816kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111110111
111111011
111111111
111111110
0
111111111
111111111
111111111
111111111
111111111
111111111
011111111
111111111
011111111
0
111111111
111111111
111111111
111111111
111111111
111111111
110111011
111111111
110111011
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
100000000
100000000
100000000
100000000
000000000
000000000
100000000
000000001
?
000000000
000000000
000000000
000000000
111111111
111111111
111111111
111111111
111111111
?
000000000
000000000
00...

result:

ok correct! (10000 test cases)

Test #16:

score: 0
Accepted
time: 459ms
memory: 4556kb

input:

10000
7
0
1111111
1111111
1010000
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1011111
1111111
1110111
1111011
1111101
1111110
0
7
0
1111111
1011111
1111111
1111111
1111011
1111111
1111111
0
1111111
0111111
1111111
1111111
0111111
1111111
111111...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
0111111
1000000
1000000
1000000
1000000
1000000
1000000
?
0000000
0100000
0010000
0001000
0000100
0000010
0000001
!
1000000
1000000
0010000
1000000
1000000
1000000
1000000
?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000100
...

result:

ok correct! (10000 test cases)

Test #17:

score: 0
Accepted
time: 577ms
memory: 5024kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111011111
111111111
111111111
111111111
111111111
111111110
0
8
0
11111111
1...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
011111111
100000000
100000000
100000000
100000000
100000000
100000000
100000000
100000000
?
000000000
010000000
001000000
000100000
000010000
000001000
000000100
000000010
000000001
!
100000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #18:

score: 0
Accepted
time: 989ms
memory: 5288kb

input:

10000
9
0
010111111
100111111
111111111
111011111
110101111
110110111
110111011
110111101
110111110
0
000000000
111111111
111111111
111111111
111111111
000000000
000000000
000000000
000000000
0
010010001
101101110
111111111
111111111
010010001
101101110
101101110
101101110
101101110
0
101101110
0100...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111111111
000000000
000000000
000000000
000000000
111111111
111111111
111111111
111111111
?
111111111
000000000
000000000
111111111
111111111
000000000
000000000
000000000
000000000
?
111111111
000000000
10...

result:

ok correct! (10000 test cases)

Test #19:

score: 0
Accepted
time: 1097ms
memory: 5324kb

input:

10000
8
0
11111111
10111111
11011111
11101111
11111111
10110111
11111101
11111111
0
10110111
11111111
11111111
11111111
11111111
11111111
11111101
11111111
0
11111111
11111111
01111101
10110111
11110111
11111111
10110111
11111110
0
11111111
01111101
11110111
01111101
11110111
11111111
01111101
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000010
00000000
00000000
00000000
10000000
10000000
00000010
10000000
?
00000000
10110010
10110010
10110010
00001000
00000100
10110010
00000001
?
00000000
10000010
11000001
10000010
00001000
00000100
10000010
00000000
?
00...

result:

ok correct! (10000 test cases)

Test #20:

score: 0
Accepted
time: 887ms
memory: 5308kb

input:

10000
7
0
1111111
0011111
0101111
0110111
0111011
0111101
0111110
0
0111110
1111111
1111111
1111111
1111111
1111111
1111110
0
1111111
0111101
1010111
1111111
0111101
1010111
1010111
0
0111111
0110111
1111111
1111111
0110111
0111111
0111111
0
0111101
1010101
1111111
1111111
1010101
0111101
0111101
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000001
0000000
0000000
0000000
0000000
0000000
0000001
?
1000111
1000111
1000111
1000111
1000111
1000111
1000111
?
1000001
1001000
1000001
1000001
1001000
1000001
1000001
?
1000010
1010000
0000000
0000000
1010000
1000010
1000010
!
0000100
...

result:

ok correct! (10000 test cases)

Test #21:

score: 0
Accepted
time: 912ms
memory: 4888kb

input:

10000
9
0
010111111
100111111
111111111
110011111
110101111
110110111
110111011
110111101
110111110
0
000000000
111111111
111111111
111111111
111111111
000000000
000000000
000000000
000000000
0
000000000
111111111
111111111
000000000
000000000
111111111
111111111
111111111
111111111
0
111111111
0000...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111111111
000000000
000000000
000000000
000000000
111111111
111111111
111111111
111111111
?
111111111
000000000
000000000
111111111
111111111
000000000
000000000
000000000
000000000
?
111111111
000000000
11...

result:

ok correct! (10000 test cases)

Test #22:

score: 0
Accepted
time: 995ms
memory: 5304kb

input:

10000
9
0
111111111
111111111
111111111
100101000
111111111
100001000
111111111
111111111
111111111
0
111111111
111111111
111111111
100001000
111111111
111111111
111111111
111111111
111111111
0
111111111
101111111
110111111
111011111
111101111
111111111
111111011
111111101
111111110
0
7
0
1111111
00...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
011111111
100000000
100000000
100000000
100000000
100000000
100000000
100000000
100000000
?
000000000
010000000
001000000
000100000
000010000
000001000
000000100
000000010
000000001
!
100000000
100000000
10...

result:

ok correct! (10000 test cases)

Test #23:

score: 0
Accepted
time: 710ms
memory: 5308kb

input:

10000
6
0
111111
111111
111111
111011
111101
111110
0
111111
111111
111111
011111
011111
011111
0
111111
111111
111111
000000
000000
000000
0
111111
111111
111111
111111
111111
111111
0
7
0
0111111
1011111
1101111
1110111
1111011
1111111
1111111
0
1111111
0000000
0000000
0000000
1111111
1111111
1111...

output:

?
000000
110000
101000
100100
100010
100001
?
100001
100000
100000
000000
000000
000001
?
000000
000000
000000
111111
111111
111111
?
000000
000000
111111
111111
000000
000000
!
000000
000000
111111
000000
000000
000000
?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1111111
0000000
0000...

result:

ok correct! (10000 test cases)

Test #24:

score: 0
Accepted
time: 359ms
memory: 4120kb

input:

10000
5
0
11111
00111
01011
01101
01110
0
11111
11111
11111
11111
11110
0
11111
01111
01111
11111
11111
0
11111
11110
01111
11011
01111
0
5
0
11111
10111
11011
11101
11111
0
11111
11111
11111
11111
11101
0
11111
11111
01101
01101
11110
0
11111
01101
11111
01111
11110
0
5
0
11111
11011
11111
11101
11...

output:

?
00000
11000
10100
10010
10001
?
10001
00000
00000
00000
00001
?
00000
10011
10011
10011
10011
?
00000
10100
10100
10001
10001
!
10000
00100
01000
00001
00010
?
00000
11000
10100
10010
10001
?
10010
00000
00000
00010
10000
?
00000
10110
10110
10110
00001
?
00000
10010
11000
11000
00001
!
00010
0010...

result:

ok correct! (10000 test cases)

Test #25:

score: 0
Accepted
time: 469ms
memory: 4120kb

input:

10000
6
0
111111
101111
110111
111111
111011
111110
0
111110
111111
111111
111111
111111
111110
0
111011
011111
111011
110110
111101
011111
0
011111
011111
101011
101110
111101
111010
0
111111
111011
111111
111101
111111
111111
0
6
0
111111
111111
110111
111011
111101
111110
0
111110
111111
111111
1...

output:

?
000000
110000
101000
100100
100010
100001
?
100001
000000
000000
100000
100000
000001
?
101001
101001
101001
000100
000010
101001
?
100001
110000
100001
000100
000010
110000
?
000000
100010
000000
000100
000000
000000
!
001000
000010
000001
000100
100000
010000
?
000000
110000
101000
100100
100010...

result:

ok correct! (10000 test cases)

Test #26:

score: 0
Accepted
time: 458ms
memory: 4132kb

input:

10000
7
0
1111111
1111111
1101111
1110111
1111011
1111101
1011111
0
1111101
1111111
1111111
1111111
1111111
1111101
1111111
0
1011111
1110001
1011111
0111111
1011111
0111111
1111110
0
0111111
1101101
1001111
1011101
0111111
0111111
1111110
0
1011110
1111010
1111111
1111111
0111111
1011011
1111111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000010
1000000
0000000
0000000
0000000
0000010
1000000
?
1001110
0100000
1001110
1001110
1001110
1001110
0000001
?
1000010
0100000
1000010
1010000
1000010
1010000
0000001
?
1000100
0100000
0000000
0000000
1000100
1000001
0000000
!
0000100
...

result:

ok correct! (10000 test cases)

Test #27:

score: 0
Accepted
time: 1007ms
memory: 5268kb

input:

10000
8
0
11111111
00111111
01011111
01101111
01110111
01111011
01111101
01111110
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111110
0
11111111
11111111
11111111
01111111
11111111
01111111
01111111
01111111
0
11111111
01111111
01111111
01111111
11100111
01111111
11111110
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
00000000
00000000
00000000
00000000
00000001
?
00000000
10000111
10000111
10000111
10000111
10000111
10000111
10000111
?
00000000
10000001
10000001
10011000
10000001
10011000
10011000
10011000
?
00...

result:

ok correct! (10000 test cases)

Test #28:

score: 0
Accepted
time: 1127ms
memory: 5240kb

input:

10000
8
0
11111111
10111111
11011111
11110100
11111100
11111011
11110110
11110101
0
11111011
11111111
11111111
11111111
11111111
11111011
11111111
11111111
0
11110100
11110100
11110100
11101111
10011000
01111111
10010010
10010001
0
01111111
11110111
01111111
11101111
11111011
01111100
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000100
00000000
00000000
10000000
10000000
00000100
10000000
10000000
?
11100100
11100100
11100100
00010000
00001000
11100100
00000010
00000001
?
10000100
10000100
10000100
00010000
00001000
10000011
00000000
00000000
?
10...

result:

ok correct! (10000 test cases)

Test #29:

score: 0
Accepted
time: 1176ms
memory: 5312kb

input:

10000
8
0
11111111
10111111
11011111
11111011
11110111
11111111
11111101
11111110
0
11111110
11111111
11111111
11111111
11111111
11111111
11111111
11111110
0
11111011
01111111
01111111
11101111
11111011
11110100
11111011
01111111
0
01111111
01111111
11111010
11101111
01111111
10011110
10011011
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
10000000
00000000
10000000
00000000
00000001
?
10001011
10001011
10001011
00010000
10001011
00000100
10001011
10001011
?
10000001
11100000
11100000
00010000
10000001
00000100
10000001
11100000
?
10...

result:

ok correct! (10000 test cases)

Test #30:

score: 0
Accepted
time: 1141ms
memory: 5240kb

input:

10000
8
0
11111111
10111111
11101101
11011101
11110111
11001101
11001111
11111110
0
11111111
11111111
11111111
11111111
11111111
11111110
11111111
11111111
0
11111111
11001101
10100101
10010101
11001101
11111011
10000111
01111110
0
11111111
01111110
11101011
11011011
01111110
11111111
11111111
11001...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
10000000
10000000
00000000
10000000
10000000
00000001
?
00000000
11001001
00100000
00010000
11001001
00000100
00000010
11001001
?
00000000
10000001
00100000
00010000
10000001
00000000
00000000
10000110
?
00...

result:

ok correct! (10000 test cases)

Test #31:

score: 0
Accepted
time: 1030ms
memory: 5252kb

input:

10000
8
0
11111111
00111111
01011111
01101111
01110111
01111011
01111101
01111110
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111110
0
11111111
01111111
11111111
11111111
01111111
01111111
11111111
01111111
0
11111111
11111110
11100111
01111111
01111111
11111110
01111111
01111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
00000000
00000000
00000000
00000000
00000001
?
00000000
10000111
10000111
10000111
10000111
10000111
10000111
10000111
?
00000000
10011000
10000001
10000001
10011000
10011000
10000001
10011000
?
00...

result:

ok correct! (10000 test cases)

Test #32:

score: 0
Accepted
time: 1155ms
memory: 5292kb

input:

10000
9
0
111111111
101111111
110111111
111011111
111111111
111110111
111111011
111111101
111111110
0
111111110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
011111111
111111111
111111111
011111111
111101111
111111111
011111111
011111111
111111111
0
011111111
0111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
000000000
000000000
100000000
000000000
000000000
000000000
000000001
?
100001111
100001111
100001111
100001111
000010000
100001111
100001111
100001111
100001111
?
101100000
100000011
10...

result:

ok correct! (10000 test cases)

Test #33:

score: 0
Accepted
time: 1008ms
memory: 5244kb

input:

10000
9
0
111111111
111111111
010111111
011011111
011101111
011110111
011111011
011111101
011111110
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
111111111
111110000
011111111
101111111
101111111
011111111
101111111
101111111
011111111
0
111111111
1110...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
100000000
000000000
000000000
000000000
000000000
000000000
000000000
000000001
?
000000000
010000000
100001111
100001111
100001111
100001111
100001111
100001111
100001111
?
000000000
010000000
10...

result:

ok correct! (10000 test cases)

Test #34:

score: 0
Accepted
time: 1249ms
memory: 5296kb

input:

10000
9
0
111111111
101111111
110111111
111011111
111111111
111110111
111111011
111111101
111111110
0
111111110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
011111111
111111111
011111111
011111111
111101111
111111111
111111111
011111111
111111111
0
111111100
0111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
000000000
000000000
100000000
000000000
000000000
000000000
000000001
?
100001111
100001111
100001111
100001111
000010000
100001111
100001111
100001111
100001111
?
101100000
100000011
10...

result:

ok correct! (10000 test cases)

Test #35:

score: 0
Accepted
time: 1092ms
memory: 5284kb

input:

10000
9
0
111111111
101111111
110111111
111011111
111101111
111110111
111111111
111111101
111111110
0
111111110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
011111111
111111111
111111111
011111111
011111111
011111111
111111011
111111111
111111111
0
011111111
1100...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
000000000
000000000
000000000
000000000
100000000
000000000
000000001
?
100011011
100011011
100011011
100011011
100011011
100011011
000000100
100011011
100011011
?
101100000
100000011
10...

result:

ok correct! (10000 test cases)

Test #36:

score: 0
Accepted
time: 1094ms
memory: 5292kb

input:

10000
9
0
111111111
111111011
110111111
111011111
111101111
111110111
111111111
111111101
111111110
0
111111110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
111111011
101111111
111111011
111111011
011111111
111111011
111100100
011111111
011111111
0
011111111
1011...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
100000000
000000000
000000000
000000000
000000000
100000000
000000000
000000001
?
100011011
010000000
100011011
100011011
100011011
100011011
000000100
100011011
100011011
?
100000011
010000000
10...

result:

ok correct! (10000 test cases)

Test #37:

score: 0
Accepted
time: 496ms
memory: 4112kb

input:

10000
7
0
1111111
1011111
1111111
1110111
1111011
1111101
1111110
0
1111110
0111111
1111111
1111111
1111111
1111111
1111110
0
1111111
0111010
1111111
1111111
1111111
1111111
1111111
0
1111111
0010011
1111111
1111111
1111111
1111111
1111110
0
1111111
1110011
1111111
1111111
1111111
1111111
1111111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000001
0000000
1000000
0000000
0000000
0000000
0000001
?
0000000
1111111
0000000
0000000
1111111
1111111
1111111
?
0000000
1111111
0000000
1000101
0000000
0000000
0111010
?
0000000
1101100
1000100
0000000
0000000
0101000
0000000
!
0000100
...

result:

ok correct! (10000 test cases)

Test #38:

score: 0
Accepted
time: 495ms
memory: 4248kb

input:

10000
8
0
11111111
10111111
11111111
11111111
11110111
11111011
11111101
11111110
0
11111110
11111111
11111111
11111111
11111111
11111111
11111111
11111110
0
01111111
01111111
11011111
11111000
11111111
11111111
01111111
11111111
0
11111110
01110111
11011111
10111110
01111111
10111111
01110111
01111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
10000000
10000000
00000000
00000000
00000000
00000001
?
10000111
10000111
00100000
00010000
10000111
10000111
10000111
10000111
?
11001000
11001000
00100000
00010000
10000001
10000001
11001000
10000001
?
10...

result:

ok correct! (10000 test cases)

Test #39:

score: 0
Accepted
time: 488ms
memory: 4204kb

input:

10000
8
0
11111111
10111111
11011111
11101111
11110111
11111011
11111111
11111110
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
01111111
11111111
11111111
11111111
01111111
11111101
01111111
0
11111111
11111111
01111111
01111111
11101111
01111111
11111101
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
00000000
00000000
00000000
10000000
00000001
?
00000000
10001101
10001101
10001101
10001101
10001101
00000010
10001101
?
00000000
10110000
10000001
10000001
10000001
10110000
00000010
10110000
?
00...

result:

ok correct! (10000 test cases)

Test #40:

score: 0
Accepted
time: 549ms
memory: 4248kb

input:

10000
8
0
11111111
10111111
11011111
11101111
11110111
11111111
11111101
11111101
0
11111101
11111111
11111111
11111111
11111111
11111111
11111101
11111101
0
01111101
11111111
11111111
01111101
01111101
11111111
01111101
11111110
0
11111101
01111101
01111101
01111111
11111101
11111111
01111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000010
00000000
00000000
00000000
00000000
10000000
00000010
10000000
?
10011010
10011010
10011010
10011010
10011010
00000100
10011010
00000001
?
11100000
10000010
10000010
11100000
11100000
00000100
11100000
00000001
?
10...

result:

ok correct! (10000 test cases)

Test #41:

score: 0
Accepted
time: 1124ms
memory: 5276kb

input:

10000
9
0
111111111
111110111
010111111
011011111
111111111
111111111
011111011
011111101
011111110
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
111111111
111110000
111110111
111110111
111111111
111111000
111111111
011011111
111111111
0
111111111
1101...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
100000000
000000000
000000000
100000000
100000000
000000000
000000000
000000001
?
000000000
010000000
100100111
100100111
000010000
000001000
100100111
100100111
100100111
?
000000000
010000000
10...

result:

ok correct! (10000 test cases)

Test #42:

score: 0
Accepted
time: 1093ms
memory: 5284kb

input:

10000
9
0
111111111
110111101
101111101
100111101
111101111
100111101
111111011
111111101
111111111
0
111111101
111111111
111111111
111111111
111111111
111111101
111111111
111111101
111111111
0
100111111
110111001
101111001
100111001
011111101
111110111
100111111
100111111
111111111
0
011111101
1101...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000010
100000000
100000000
100000000
000000000
100000000
000000000
000000010
100000000
?
100010111
010000000
001000000
000100000
100010111
000001000
100010111
100010111
000000000
?
100000110
010000000
00...

result:

ok correct! (10000 test cases)

Test #43:

score: 0
Accepted
time: 1076ms
memory: 5256kb

input:

10000
9
0
111111111
101111111
111111111
111011111
111101111
111110111
111111111
111111101
111111110
0
111111110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
011111111
011111111
111111111
111111111
111111111
011111111
111111011
111111111
111111111
0
011111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
100000000
000000000
000000000
000000000
100000000
000000000
000000001
?
100011011
100011011
001000000
100011011
100011011
100011011
000000100
100011011
100011011
?
110100000
110100000
00...

result:

ok correct! (10000 test cases)

Test #44:

score: 0
Accepted
time: 479ms
memory: 4176kb

input:

10000
7
0
1111111
1111111
1101111
1110111
1111011
1111111
1111110
0
1111110
1111111
1111111
1111111
1111111
1111111
1111110
0
1111111
1111111
0111111
1111111
1111111
1111101
1111111
0
0111111
1111111
0101111
1111111
0111111
1111101
0111111
0
0111111
1111111
1111111
1111111
0111111
1111111
1111111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000001
1000000
0000000
0000000
0000000
1000000
0000001
?
1001101
0100000
1001101
1001101
1001101
0000010
1001101
?
1000001
0100000
1010000
1000001
1000001
0000010
1000001
?
1000100
0100000
1000010
0000000
1000100
0000000
1000100
!
0001000
...

result:

ok correct! (10000 test cases)

Test #45:

score: 0
Accepted
time: 538ms
memory: 4168kb

input:

10000
8
0
11111111
11111111
11011111
11101111
11111111
11111011
11111101
11111110
0
11111110
11111111
11111111
11111111
11111111
11111111
11111111
11111110
0
11111111
10111111
11111111
01111101
11110111
01111101
11111111
01111101
0
01111111
10111111
11011111
01101111
11110111
01101111
01111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
10000000
00000000
00000000
10000000
00000000
00000000
00000001
?
10000111
01000000
10000111
10000111
00001000
10000111
10000111
10000111
?
10000001
01000000
10000001
10110000
00001000
10110000
10000001
10110000
?
10...

result:

ok correct! (10000 test cases)

Test #46:

score: 0
Accepted
time: 512ms
memory: 4128kb

input:

10000
8
0
11111111
00111111
11111111
01101111
11111111
01111011
01111101
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111101
11111111
0
11111111
01111101
11111111
11111111
11111111
11111111
01111101
11101111
0
11111111
00111110
11111111
01111101
11111111
01111101
00111110
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000010
00000000
10000000
00000000
10000000
00000000
00000010
10000000
?
00000000
10010110
00100000
10010110
00001000
10010110
10010110
00000001
?
00000000
11000001
00100000
10000010
00001000
10000010
11000001
00000000
?
00...

result:

ok correct! (10000 test cases)

Test #47:

score: 0
Accepted
time: 565ms
memory: 4176kb

input:

10000
8
0
11111111
10111111
11011111
11111111
11110111
11111011
11111101
11111110
0
11111110
11111111
11111111
11111111
11111111
11111111
11111111
11111110
0
11111111
11111111
11111111
11101111
11111111
01111111
11111111
11111111
0
01111111
01111111
01111111
11101111
01111111
11111110
11111111
01111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
10000000
00000000
00000000
00000000
00000001
?
10000111
10000111
10000111
00010000
10000111
10000111
10000111
10000111
?
10000001
10000001
10000001
00010000
10000001
10101000
10000001
10000001
?
10...

result:

ok correct! (10000 test cases)

Test #48:

score: 0
Accepted
time: 1152ms
memory: 5368kb

input:

10000
9
0
111111111
101111111
110111111
111011111
111101111
111110111
111111111
111111101
111111111
0
111111101
111111111
111111111
111111111
111111111
111111111
111111111
111111101
111111111
0
011111111
011111111
111111111
111111111
111111111
111111111
111111011
011111111
111111110
0
111111111
0011...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000010
000000000
000000000
000000000
000000000
000000000
100000000
000000010
100000000
?
100111010
100111010
100111010
100111010
100111010
100111010
000000100
100111010
000000001
?
111000000
111000000
10...

result:

ok correct! (10000 test cases)

Test #49:

score: 0
Accepted
time: 1236ms
memory: 5268kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111101111
111110111
111111011
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111011111
011101010
011101010
111111101
111111111
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000100
100000000
100000000
100000000
000000000
000000000
000000100
100000000
100000000
?
000000000
010000000
001000000
000100000
100011101
100011101
100011101
000000010
000000000
?
000000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #50:

score: 0
Accepted
time: 1173ms
memory: 5312kb

input:

10000
9
0
111111111
111111111
110111111
111111111
111111111
111110111
111111011
111111101
111111111
0
111111101
111111111
111111111
111111111
111111111
111111111
111111111
111111101
111111111
0
111111111
111111111
111111111
111111111
111101111
111111111
011110111
111111111
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000010
100000000
000000000
100000000
100000000
000000000
000000000
000000010
100000000
?
101001110
010000000
101001110
000100000
000010000
101001110
101001110
101001110
000000001
?
100000110
010000000
10...

result:

ok correct! (10000 test cases)

Test #51:

score: 0
Accepted
time: 304ms
memory: 3892kb

input:

10000
7
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111011
1111111
1111111
0
7
0
1111111
1111111
1111111
1111111
1111011
1111111
1111111
0
1111111
1111111
1111111
1111111
0111111
1111111
111111...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
0111111
1000000
1000000
1000000
1000000
1000000
1000000
?
0000000
0100000
0010000
0001000
0000100
0000010
0000001
!
1000000
0100000
0010000
0001000
1000000
0000010
0000001
?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000100
...

result:

ok correct! (10000 test cases)

Test #52:

score: 0
Accepted
time: 404ms
memory: 3884kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
01111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
01111110
11111111
11111111
11111111
11111111
11111111
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
01111111
10000000
10000000
10000000
10000000
10000000
10000000
10000000
?
10000111
01000000
00100000
00010000
00001000
00000000
00000000
00000000
?
10000001
01000000
00100000
00010000
00001000
00000100
00000010
00000000
?
10...

result:

ok correct! (10000 test cases)

Test #53:

score: 0
Accepted
time: 557ms
memory: 4116kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
11011111
11111111
11111111
11111111
11111111
11111111
0
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
1...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
01111111
10000000
10000000
10000000
10000000
10000000
10000000
10000000
?
00000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
!
10000000
10000000
10000000
00010000
00001000
00000100
00000010
00000001
?
00...

result:

ok correct! (10000 test cases)

Test #54:

score: 0
Accepted
time: 470ms
memory: 4180kb

input:

10000
8
0
11111111
10111111
11111111
11101111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
01111111
11111111
11111111
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10010000
00000000
10000000
00010000
10000000
10000000
10000000
10000000
?
00000000
11010001
00100000
11010001
00001000
00000100
00000010
00000000
?
00000000
10010000
00100000
10010000
00001000
00000100
00000010
00000001
?
00...

result:

ok correct! (10000 test cases)

Test #55:

score: 0
Accepted
time: 295ms
memory: 3844kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
11111111
11111111
11111111
11111111
11111111
11111111
0
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
1...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
01111111
10000000
10000000
10000000
10000000
10000000
10000000
10000000
?
00000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
!
10000000
10000000
00100000
00010000
00001000
00000100
00000010
00000001
?
00...

result:

ok correct! (10000 test cases)

Test #56:

score: 0
Accepted
time: 1165ms
memory: 4280kb

input:

10000
9
0
111111111
111111111
111111111
111011111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
011011000
111111111
111110111
111111111
111111111
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100100000
100000000
100000000
000100000
100000000
100000000
100000000
100000000
100000000
?
000000000
010000000
001000000
100100111
000010000
000001000
000000000
000000000
000000000
?
000000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #57:

score: 0
Accepted
time: 923ms
memory: 5280kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
101111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
9
0
111111111
...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
011111111
100000000
100000000
100000000
100000000
100000000
100000000
100000000
100000000
?
000000000
010000000
001000000
000100000
000010000
000001000
000000100
000000010
000000001
!
100000000
100000000
00...

result:

ok correct! (10000 test cases)

Test #58:

score: 0
Accepted
time: 730ms
memory: 4268kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111110111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
101111111
110111111
111111111
111101111
111111111
111111111
111111111
111111111
0
111111111
1011...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100001000
100000000
100000000
100000000
100000000
000001000
100000000
100000000
100000000
?
000000000
010000000
001000000
000100000
000010000
100001111
000000000
000000000
000000000
?
000000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #59:

score: 0
Accepted
time: 866ms
memory: 5220kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
9
0
111111111
...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
011111111
100000000
100000000
100000000
100000000
100000000
100000000
100000000
100000000
?
000000000
010000000
001000000
000100000
000010000
000001000
000000100
000000010
000000001
!
100000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #60:

score: 0
Accepted
time: 1090ms
memory: 4836kb

input:

10000
7
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111011
1111111
1111111
0
7
0
1111111
1111111
1111111
1111111
1111011
1111111
1111111
0
1111111
1111111
1111111
1111111
1111011
1111111
111111...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
0111111
1000000
1000000
1000000
1000000
1000000
1000000
?
0000000
0100000
0010000
0001000
0000100
0000010
0000001
!
1000000
0100000
0010000
0001000
1000000
0000010
0000001
?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000100
...

result:

ok correct! (10000 test cases)

Test #61:

score: 0
Accepted
time: 917ms
memory: 4240kb

input:

10000
7
0
1111111
1011111
1111110
1110111
1111111
1111111
1111111
0
1111111
1111111
1111111
1110111
1111111
1111111
1111111
0
1111111
1111111
1101111
0011110
1111011
1111111
1111111
0
1111111
1111111
1101111
1111111
1111011
1111111
1111111
0
7
0
1111111
1111111
1111111
1111111
1111111
1111111
111111...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1001000
0000000
1000000
0001000
1000000
1000000
1000000
?
0000000
1101001
0010000
1101001
0000100
0000010
0000000
?
0000000
1001000
0010000
1000010
0000100
0000000
0000001
!
1000000
0001000
1000000
0000010
1000000
0000010
0000001
?
0000000
...

result:

ok correct! (10000 test cases)

Test #62:

score: 0
Accepted
time: 893ms
memory: 4268kb

input:

10000
9
0
111111111
101111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111110111
111111111
111111111
111111111
0
111111111
0011...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110000000
010000000
100000000
100000000
100000000
100000000
100000000
100000000
100000000
?
000000000
110000111
001000000
000100000
000010000
000001000
000000000
000000000
000000000
?
000000000
110000001
00...

result:

ok correct! (10000 test cases)

Test #63:

score: 0
Accepted
time: 557ms
memory: 4236kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111011
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
11111111
11111111
11111111
01111011
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000100
10000000
10000000
10000000
10000000
00000100
10000000
10000000
?
00000000
01000000
00100000
00010000
00001000
10000111
00000000
00000000
?
00000000
01000000
00100000
00010000
00001000
10000100
00000010
00000001
?
00...

result:

ok correct! (10000 test cases)

Test #64:

score: 0
Accepted
time: 605ms
memory: 4236kb

input:

10000
9
0
111111111
101111111
111111111
111011111
111101111
111110111
111111111
111111111
111111110
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
011111111
111111111
111111111
111111111
111111111
111111111
111111101
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
100000000
000000000
000000000
000000000
100000000
100000000
000000001
?
000000000
100111001
001000000
100111001
100111001
100111001
000000100
000000010
100111001
?
000000000
110000010
00...

result:

ok correct! (10000 test cases)

Test #65:

score: 0
Accepted
time: 766ms
memory: 4948kb

input:

10000
6
0
111111
101111
110111
111100
111101
111101
0
111101
111111
111111
111111
111101
111111
0
011101
111110
011101
110100
011101
111111
0
011111
011101
111100
101100
011111
111111
0
011110
111111
111111
111101
011110
111111
0
6
0
111111
001111
010111
011011
011101
011110
0
101111
111111
111111
1...

output:

?
000000
110000
101000
100100
100010
100001
?
100010
000000
000000
100000
000010
100000
?
101010
101010
101010
000100
101010
000001
?
110000
100010
110000
000100
110000
000001
?
100001
000000
000000
000100
100001
000000
!
000100
001000
010000
000100
000100
000001
?
000000
110000
101000
100100
100010...

result:

ok correct! (10000 test cases)

Test #66:

score: 0
Accepted
time: 470ms
memory: 4164kb

input:

10000
7
0
1111111
1110010
1101111
1111010
1111011
1111101
1110011
0
1111010
1111010
1111111
1111111
1111111
1111101
1111010
0
1111111
1011111
1110110
1101000
1110110
0111011
1111110
0
1111111
1011111
1110010
1111000
0111111
0111110
1111111
0
1111111
1011111
1111111
1111111
0111011
0110111
1111110
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000010
1000000
0000000
1000000
0000000
0000010
1000000
?
0000000
0100000
1010110
0001000
1010110
1010110
0000001
?
0000000
0100000
1000010
0001000
1000010
1000001
0000000
?
0000000
0100000
0000000
0000000
1000100
1001000
0000001
!
1000000
...

result:

ok correct! (10000 test cases)

Test #67:

score: 0
Accepted
time: 463ms
memory: 4128kb

input:

10000
7
0
1111111
0011111
0101111
0110111
1111101
1111111
0111110
0
0111110
1111111
1111111
1111111
0111111
0111111
1111110
0
0100110
0100110
0100110
0100110
0111101
1111111
0100110
0
0011111
0011111
0011111
0011111
0111101
1111111
0011111
0
0111101
0111101
0111101
0111101
0111111
1111111
0111101
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000001
0000000
0000000
0000000
1000000
1000000
0000001
?
1011001
1011001
1011001
1011001
0000100
0000010
1011001
?
1100000
1100000
1100000
1100000
0000100
0000010
1100000
?
1000010
1000010
1000010
1000010
0000100
0000000
1000010
!
0000100
...

result:

ok correct! (10000 test cases)

Test #68:

score: 0
Accepted
time: 531ms
memory: 4220kb

input:

10000
7
0
1111111
0011111
0101111
0110111
0111011
0111101
0111110
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
0111000
0111000
0111000
0111000
0111000
0111000
0
1111111
0111111
1111101
0111111
0111111
1111101
1111101
0
1111111
1111101
1111111
1111101
1111101
1111111
1111111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000001
0000000
0000000
0000000
0000000
0000000
0000001
?
0000000
1000111
1000111
1000111
1000111
1000111
1000111
?
0000000
1001000
1001000
1001000
1001000
1001000
1001000
?
0000000
1010000
0000000
1010000
1010000
0000000
0000000
!
0000001
...

result:

ok correct! (10000 test cases)

Test #69:

score: 0
Accepted
time: 492ms
memory: 4128kb

input:

10000
7
0
1111111
1011111
1101111
1001111
1111011
1001111
1111110
0
1111110
1111111
1111111
1001111
1111111
1111111
1111110
0
0101111
1111111
1011111
1110111
0101111
1001010
1011111
0
0011111
0111111
1001111
1110111
0011111
1001110
0111111
0
1001011
1111111
1111111
1110111
1001011
1111111
1001111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1000001
0000000
0000000
1000000
0000000
1000000
0000001
?
1010101
1010101
1010101
0001000
1010101
0000010
1010101
?
1100000
1000001
1000001
0001000
1100000
0000010
1000001
?
1000010
1000100
0000000
0001000
1000010
0000000
1000100
!
0000010
...

result:

ok correct! (10000 test cases)

Test #70:

score: 0
Accepted
time: 569ms
memory: 4164kb

input:

10000
8
0
11111111
10111111
11011111
11111100
11110111
11111011
11111110
11111110
0
11111110
11111111
11111111
11111110
11111111
11111111
11111111
11111110
0
01111110
11111101
11111101
11101111
01111110
01111110
11110010
01111110
0
01111111
01111110
01111110
11101111
11111100
01111111
10011110
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
10000000
00000000
00000000
10000000
00000001
?
10001101
10001101
10001101
00010000
10001101
10001101
00000010
10001101
?
11100000
10000001
10000001
00010000
11100000
11100000
00000010
11100000
?
10...

result:

ok correct! (10000 test cases)

Test #71:

score: 0
Accepted
time: 573ms
memory: 4192kb

input:

10000
8
0
11111111
10111111
11011111
11101111
11111111
11111011
11111101
11111110
0
11111110
11111111
11111111
11111111
11110111
11111111
11111111
11111110
0
01111111
01111111
11110111
11110111
11110111
11110111
01111111
01111111
0
01111111
11110110
01111111
01111111
11110111
11000111
11110110
11110...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
00000000
00000000
10000000
00000000
00000000
00000001
?
10000111
10000111
10000111
10000111
00001000
10000111
10000111
10000111
?
10110000
10110000
10000001
10000001
00001000
10000001
10110000
10110000
?
11...

result:

ok correct! (10000 test cases)

Test #72:

score: 0
Accepted
time: 486ms
memory: 4128kb

input:

10000
8
0
11111111
11111111
11011111
11101111
11111111
11111011
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
01001011
01001011
11111111
01001011
11111111
11111111
0
11111111
10111111
01111100
01111100
11111111
01111100
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000100
10000000
00000000
00000000
10000000
00000100
10000000
10000000
?
00000000
01000000
10110100
10110100
00001000
10110100
00000010
00000001
?
00000000
01000000
10000011
10000011
00001000
10000011
00000000
00000000
?
00...

result:

ok correct! (10000 test cases)

Test #73:

score: 0
Accepted
time: 635ms
memory: 4184kb

input:

10000
8
0
01011111
10011111
11111111
11001111
11110111
11011111
11011101
11011110
0
10000000
01111111
11111111
01111111
11111111
11111111
10000000
10000000
0
00010001
11111110
11111111
10010001
11111111
11111111
11111110
01111110
0
01111111
10010000
11111111
10010000
10010001
11111111
00010000
10010...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11111111
00000000
00000000
00000000
00000000
11111111
11111111
11111111
?
11111111
00000000
00000000
01111111
01111111
00000000
00000000
10000000
?
11111111
00000000
01101110
00000000
00010001
00000000
10000000
00000000
!
00...

result:

ok correct! (10000 test cases)

Test #74:

score: 0
Accepted
time: 499ms
memory: 4176kb

input:

10000
8
0
11111111
11111111
11011111
11101111
11111111
11011101
11111111
11111111
0
11101111
11111111
11111111
11101111
11111111
11111111
11111111
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111101
11111111
0
01101111
11111111
01101111
01101111
11111111
11111111
11111101
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10010000
10000000
00000000
00010000
10000000
10000000
10000000
10000000
?
10110001
01000000
10110001
10110001
00001000
00000100
00000010
00000000
?
10010000
01000000
10010000
10010000
00001000
00000100
00000010
00000001
?
10...

result:

ok correct! (10000 test cases)

Test #75:

score: 0
Accepted
time: 546ms
memory: 4236kb

input:

10000
8
0
11111111
10111101
11111101
11101101
11110101
11111001
11111111
11111100
0
11111110
01111111
11111111
01111111
01111111
01111111
11111111
01111110
0
11111111
01110011
11111111
10001100
10001100
01110011
11111111
01110011
0
11111111
00000000
11111111
01110011
01110011
11111111
11111111
10001...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000001
00000000
10000000
00000000
00000000
00000000
10000000
00000001
?
00000000
11111111
00000000
00000000
00000000
11111111
11111111
11111111
?
00000000
11111111
00000000
10001100
10001100
00000000
00000000
01110011
?
00...

result:

ok correct! (10000 test cases)

Test #76:

score: 0
Accepted
time: 532ms
memory: 4124kb

input:

10000
8
0
11111111
00111111
01011111
11111111
01110111
01111011
11111111
11111111
0
11111111
01111111
01111111
11111111
11111111
01111011
11111111
11111111
0
11111111
01011111
11111111
11111111
11111111
01011111
11111111
11111111
0
11111111
00011001
11111111
01011111
01011111
11111111
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000100
00000000
00000000
10000000
00000000
00000100
10000000
10000000
?
00000000
11111111
00000000
00000000
00000000
11111111
11111111
11111111
?
00000000
11111111
00000000
10100000
10100000
00000000
00000000
01011111
?
00...

result:

ok correct! (10000 test cases)

Test #77:

score: 0
Accepted
time: 1259ms
memory: 5340kb

input:

10000
9
0
111111111
101111111
110111111
110111111
111101111
111110111
111111011
111111101
111111110
0
111111111
111111111
111111111
110111110
111111111
111111111
111111111
111111111
111111111
0
111111111
110111111
110111111
111011111
011111110
011111110
110111111
110111111
110111111
0
111111111
1101...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
000000000
100000000
000000000
000000000
000000000
000000000
000000001
?
000000000
100001111
100001111
000100000
100001111
100001111
100001111
100001111
100001111
?
000000000
100000011
10...

result:

ok correct! (10000 test cases)

Test #78:

score: 0
Accepted
time: 1239ms
memory: 5348kb

input:

10000
9
0
111111111
101111111
110111111
111111111
111101111
111110111
111111011
111111111
111111110
0
111111110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111110
0
011111111
011111111
011111111
111011111
011111111
111111111
111111111
111100110
111111111
0
111111110
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
000000000
100000000
000000000
000000000
000000000
100000000
000000001
?
100011101
100011101
100011101
000100000
100011101
100011101
100011101
000000010
100011101
?
111000000
111000000
11...

result:

ok correct! (10000 test cases)

Test #79:

score: 0
Accepted
time: 1061ms
memory: 5264kb

input:

10000
9
0
111111111
001111111
101111101
100111101
011101111
011110111
111111111
011111101
011111110
0
011111110
111111111
011111111
011111111
111111111
111111111
011111111
111111111
111111110
0
011101101
111111111
001110100
000110100
100111111
011101101
111111111
011101101
011101101
0
001111011
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000001
000000000
100000000
100000000
000000000
000000000
100000000
000000000
000000001
?
100011011
100011011
001000000
000100000
100011011
100011011
000000100
100011011
100011011
?
110000100
100000011
00...

result:

ok correct! (10000 test cases)

Test #80:

score: 0
Accepted
time: 1033ms
memory: 5376kb

input:

10000
9
0
111111111
111111111
110111111
111011111
111101111
111111111
111111111
111111101
111111111
0
111111101
111111111
111111111
111111111
111111111
111111111
111111111
111111101
111111111
0
111111111
101111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
1011...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000010
100000000
000000000
000000000
000000000
100000000
100000000
000000010
100000000
?
101110010
010000000
101110010
101110010
101110010
000001000
000000100
101110010
000000001
?
100010010
010000000
10...

result:

ok correct! (10000 test cases)

Extra Test:

score: 0
Extra Test Passed