QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#329440#7788. Rook Detectionyz_lyAC ✓1049ms5828kbC++145.1kb2024-02-16 18:22:502024-02-16 18:22:50

Judging History

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

  • [2024-02-16 18:22:50]
  • 评测
  • 测评结果:AC
  • 用时:1049ms
  • 内存:5828kb
  • [2024-02-16 18:22:50]
  • 提交

answer

#include<bits/stdc++.h>
using namespace std;
inline int read(){
	char ch=getchar();
	int f=1,x=0;
	while(ch<'0'||ch>'9'){
		if(ch=='-')
			f=-f;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9'){
		x=x*10+ch-'0';
		ch=getchar();
	}
	return f*x;
}
inline void work(int k){
	if(k<0){
		putchar('-');
		k=-k;
	}
	if(k>9)
		work(k/10);
	putchar(k%10+'0');
}
/*

*/

int t,n,c[505][505],d[505][505],id[505],gg[505];
pair<int,int> ans[505];
pair<int,int> q[505];
void init(){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			c[i][j]=0;
		}
	}
}
void ask(){
	puts("?");
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			work(c[i][j]);
		}
		putchar('\n');
	}
	fflush(stdout);
}
void report(){
	puts("!");
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			work(c[i][j]);
		}
		putchar('\n');
	}
	fflush(stdout);
	int c;
	scanf("%d",&c);
	if(c){
		if(n==5)
			exit(-1);
		exit(0);
	}
}
void receive(){
	int c;
	scanf("%d",&c);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			scanf("%1d",d[i]+j);
		}
	}
}
void solve(int N){
	for(int i=1;i<=n;i++){
		q[i]=make_pair(1,N);
	}
	while(1){
		int flag=0;
		for(int i=1;i<=n;i++){
			if(q[i].second!=q[i].first)
				flag=1;
		}
		if(!flag)
			break;
		init();
		for(int i=1;i<=n;i++){
			if(q[i].second!=q[i].first){
				int mid=(q[i].second+q[i].first)>>1;
				for(int j=mid+1;j<=q[i].second;j++){
					c[id[j]][i]=1;
				}
			}
			c[id[N+1]][i]=1;
		}
		ask();
		receive();
		for(int i=1;i<=n;i++){
			if(q[i].second!=q[i].first){
				int mid=(q[i].second+q[i].first)>>1;
				if(d[id[N+1]][i])
					q[i]=make_pair(mid+1,q[i].second);
				else
					q[i]=make_pair(q[i].first,mid);
			}
		}
	}
	init();
	for(int i=1;i<=n;i++){
		c[id[q[i].first]][i]=1;
	}
	report();
}
int main(){
	t=read();
	while(t--){
		n=read();
		init();
		for(int i=2;i<=n;i++){
			c[i][1]=1;
			c[i][i]=1;
		}
		ask();
		receive();
		if(!d[1][1]){
			for(int i=1;i<n;i++){
				id[i]=i+1;
			}
			id[n]=1;
			solve(n-1);
			continue;
		}
		init();
		int fff=0;
		for(int i=2;i<=n;i++){
			if(d[i][i])
				c[i][i]=c[i][1]=1;
			else
				c[i][i]=c[1][i]=1,fff=1;
		}
		int ff=0,cnt=0;
		if(!fff){
			int cnt1=0;
			init();
			for(int i=1;i<=n;i++){
				c[i][i]=1;
			}
			ask();
			receive();
			for(int i=2;i<=n;i++){
				if(d[i][i])
					ans[++cnt1]=make_pair(i,i);
				else
					ans[++cnt1]=make_pair(i,1);
			}
			if(d[1][1])
				ans[++cnt1]=make_pair(1,1);
			else{
				int l=2,r=n;
				while(l<r){
					int mid=(l+r)>>1;
					init();
					for(int i=mid+1;i<=n;i++){
						c[1][i]=1;
					}
					c[1][1]=1;
					ask();
					receive();
					if(d[1][1])
						l=mid+1;
					else
						r=mid;
				}
				ans[++cnt1]=make_pair(1,l);
			}
			init();
			for(int i=1;i<=cnt1;i++){
				c[ans[i].first][ans[i].second]=1;
			}
			report();
			continue;
		}
		else
			c[1][1]=1;
		ask();
		receive();
		int f=0;
		for(int i=2;i<=n;i++){
			if(c[1][i]&&!d[i][1]){
				f=i;
				break;
			}
		}
		if(f){
			for(int i=1;i<n;i++){
				id[i]=i+(i>=f);
			}
			id[n]=f;
			solve(n-1);
			continue;
		}/*否则每行都有,直接二分*/
		int cnt1=0,cnt2=0;
		for(int i=2;i<=n;i++){
			if(c[1][i]){
				if(d[i][i]){
					ans[++cnt1]=make_pair(1,i);
					ff=1;
				}
				id[++cnt]=i;
			}
			else
				gg[++cnt2]=i;
		}
		if(!ff){
			for(int i=2;i<=n;i++){
				if(c[1][i]&&d[1][i]){
					ans[++cnt1]=make_pair(1,1);
					ff=1;
					break;
				}
			}
			if(!ff)
				id[++cnt]=1;
		}
		for(int i=1;i<=cnt;i++){
			q[i]=make_pair(2,n);/*注意是log(n-1)次*/
		}
		while(1){
			int flag=0;
			for(int i=1;i<=cnt;i++){
				if(q[i].second!=q[i].first)
					flag=1;
			}
			if(!flag)
				break;
			init();
			for(int i=1;i<=cnt;i++){
				if(q[i].second!=q[i].first){
					int mid=(q[i].second+q[i].first)>>1;
					for(int j=mid+1;j<=q[i].second;j++){
						c[id[i]][j]=1;
					}
				}
				c[id[i]][1]=1;
			}
			int cnt3=0;
			for(int i=1;i<=cnt2;i++){
				int flag=0;
				for(int j=1;j<=n;j++){
					if(c[j][gg[i]])
						flag=1;
				}
				if(!flag)
					c[gg[i]][gg[i]]=1;
				else
					swap(gg[++cnt3],gg[i]);
			}
			ask();
			receive();
			for(int i=1;i<=cnt;i++){
				if(q[i].second!=q[i].first){
					int mid=(q[i].second+q[i].first)>>1;
					if(d[id[i]][1])
						q[i]=make_pair(mid+1,q[i].second);
					else
						q[i]=make_pair(q[i].first,mid);
				}
			}
			for(int i=cnt3+1;i<=cnt2;i++){
				if(d[gg[i]][gg[i]])
					ans[++cnt1]=make_pair(gg[i],gg[i]);
				else
					ans[++cnt1]=make_pair(gg[i],1);
			}
			cnt2=cnt3;
		}
		if(cnt2){
			init();
			for(int i=1;i<=cnt2;i++){
				c[gg[i]][gg[i]]=1;
			}
			ask();
			receive();
			for(int i=1;i<=cnt2;i++){
				if(d[gg[i]][gg[i]])
					ans[++cnt1]=make_pair(gg[i],gg[i]);
				else
					ans[++cnt1]=make_pair(gg[i],1);
			}
		}/*向上取整,n不是2的整数次幂可以,n是2的整数次幂,因为是log(n-1),也会多一次,直接问就行了*/
		init();
		for(int i=1;i<=cnt;i++){
			c[id[i]][q[i].first]=1;
		}
		for(int i=1;i<=cnt1;i++){
			c[ans[i].first][ans[i].second]=1;
		}
		report();
	}
	return 0;
}

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

Details

Tip: Click on the bar to expand more detailed information

Test #1:

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

input:

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

output:

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

result:

ok correct! (1 test case)

Test #2:

score: 0
Accepted
time: 57ms
memory: 3836kb

input:

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

output:

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

result:

ok correct! (9898 test cases)

Test #3:

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

input:

10000
4
0
1111
1011
1111
1111
0
1111
1111
1111
1111
0
1111
1111
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
0110
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1011
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #4:

score: 0
Accepted
time: 66ms
memory: 3716kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #5:

score: 0
Accepted
time: 83ms
memory: 3848kb

input:

10000
4
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
1111
1111
0
1111
1111
1111
1110
0
4
0
1111
1111
1111
1101
0
1111
1011
1111
1110
0
4
0
1111
1101
1011
1001
0
0111
1111
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
1111
0
0111
1111
...

output:

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

result:

ok correct! (10000 test cases)

Test #6:

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

input:

10000
4
0
1111
1111
1111
1111
0
0111
1111
1101
1111
0
0110
1111
1111
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
1111
1111
1111
0
4
0
1111
1111
1111
1110
0
1111
1110
1110
1111
0
1111
1111
1111
0110
0
1111
1111
1111
1111
0
4
0
1111
1111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #7:

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

input:

7368
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
1111
0
0111
1011
1111
1111
0
0110
1111
1111
1111
0
0100
1111
1111
1111
0
4
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
1111
1111
1111
1111
0
4
0
1111
1111
1111
1110
0
1111
1111
1111
1111
0
1111
1111
1111
...

output:

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

result:

ok correct! (7368 test cases)

Test #8:

score: 0
Accepted
time: 663ms
memory: 5652kb

input:

10000
9
0
111111111
101111111
110111111
111111111
111101111
111110111
111111111
111111111
111111111
0
111111110
111111111
110111111
111111111
111101111
111110111
111111111
111111111
111111111
0
111111111
011110110
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111011000
010000000
001000000
100100000
000010000
000001000
100000100
100000010
100000001
?
000000000
100001111
100001111
000100000
100001111
100001111
000000000
000000000
000000000
?
000000000
100110000
10...

result:

ok correct! (10000 test cases)

Test #9:

score: 0
Accepted
time: 508ms
memory: 5548kb

input:

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

output:

?
00000
11000
10100
10010
10001
?
11000
01000
10100
10010
10001
?
00000
10011
00100
00000
00000
?
00000
10001
00000
00010
00000
?
00000
00000
00000
00000
00001
!
10000
00010
10000
00010
10000
?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11001100
01000000
10100000
10010...

result:

ok correct! (10000 test cases)

Test #10:

score: 0
Accepted
time: 588ms
memory: 5640kb

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
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #11:

score: 0
Accepted
time: 629ms
memory: 5808kb

input:

10000
4
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
6
0
111111
111111
111111
111111
111101
111111
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
011100
111111
0
111111
111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #12:

score: 0
Accepted
time: 284ms
memory: 5408kb

input:

10000
6
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
111111111
111111111
111111111
0
6
0
111111
111...

output:

?
000000
110000
101000
100100
100010
100001
?
100000
010000
001000
000100
000010
000001
!
100000
010000
001000
000100
000010
000001
?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100000000
010000000
001000000
000100000
000010000
000001000
000000100
0000...

result:

ok correct! (10000 test cases)

Test #13:

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

input:

10000
6
0
111111
101111
110111
111011
100010
111110
0
111111
101111
110111
111011
100010
111110
0
111111
100011
100011
100011
111111
100011
0
111111
011110
011110
011110
111101
011110
0
8
0
11111111
11000110
10100110
11101111
10001110
11111011
10000110
11111110
0
10010111
11000110
10100110
11101111
...

output:

?
000000
110000
101000
100100
100010
100001
?
111101
010000
001000
000100
100010
000001
?
000000
100011
100011
100011
000000
100011
?
000000
100001
100001
100001
000010
100001
!
100000
000010
000010
000010
100000
000010
?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
1001...

result:

ok correct! (10000 test cases)

Test #14:

score: 0
Accepted
time: 390ms
memory: 5472kb

input:

10000
6
0
111111
001111
010111
011011
011101
011110
0
111111
010101
111111
000001
000111
000100
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
?
111111
010000
001000
000100
000010
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: 419ms
memory: 5452kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111110111
111111011
111111111
111111110
0
111111111
111111111
111111111
111111111
111111111
111110111
011111011
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
?
100001101
110000000
101000000
100100000
100010000
000001000
000000100
100000010
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: 380ms
memory: 5476kb

input:

10000
7
0
1111111
1111111
1010000
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
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
111111...

output:

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

result:

ok correct! (10000 test cases)

Test #17:

score: 0
Accepted
time: 442ms
memory: 5372kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111011111
111111111
111111111
111111111
111111111
111111110
0
8
0
11111111
10111111
11011111
11101111
11110111
11111111
11111111
11111110
0
11111111
01111111
01111111
0...

output:

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

result:

ok correct! (10000 test cases)

Test #18:

score: 0
Accepted
time: 918ms
memory: 5604kb

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: 882ms
memory: 5744kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #20:

score: 0
Accepted
time: 811ms
memory: 5692kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #21:

score: 0
Accepted
time: 788ms
memory: 5680kb

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: 909ms
memory: 5740kb

input:

10000
9
0
111111111
111111111
111111111
100101000
111111111
100001000
111111111
111111111
111111111
0
111111111
101111111
110111111
111011111
111101111
111111111
111111011
111111101
111111110
0
7
0
1111111
0011111
1111111
1111111
0111011
0111101
1111111
0
0011001
1011111
1111111
1111111
1111011
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #23:

score: 0
Accepted
time: 596ms
memory: 5600kb

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
?
100111
110000
101000
000100
000010
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: 266ms
memory: 4856kb

input:

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

output:

?
00000
11000
10100
10010
10001
?
11111
01000
00100
00010
00001
?
00000
10011
10011
10011
10011
?
00000
10100
10100
10001
10001
!
10000
00100
01000
00001
00010
?
00000
11000
10100
10010
10001
?
11110
01000
00100
00010
10001
?
00000
10011
10011
10011
00000
?
00000
10100
10100
10001
00000
?
00000
0000...

result:

ok correct! (10000 test cases)

Test #25:

score: 0
Accepted
time: 322ms
memory: 4840kb

input:

10000
6
0
111111
101111
110111
111111
111011
111110
0
111011
101111
111111
110111
110011
111110
0
111111
111011
111011
111100
111111
011111
0
111111
011111
111111
111111
111101
011011
0
111111
011111
011111
111111
111111
010111
0
6
0
111111
111111
110111
111011
111101
111110
0
111111
110111
111111
1...

output:

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

result:

ok correct! (10000 test cases)

Test #26:

score: 0
Accepted
time: 395ms
memory: 4772kb

input:

10000
7
0
1111111
1111111
1101111
1110111
1111011
1111101
1011111
0
1011111
1111011
1101111
1110111
1111111
1111101
1011011
0
1111111
1111100
1011111
0111011
0111011
1011111
1111111
0
1111111
1111111
0111111
0111111
1111110
1110111
1111111
0
1111111
1111111
1101111
1111101
0111111
0111111
1111110
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #27:

score: 0
Accepted
time: 949ms
memory: 5800kb

input:

10000
8
0
11111111
00111111
01011111
01101111
01110111
01111011
01111101
01111110
0
11111111
10111111
11011111
11101111
11110111
11111011
11111101
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
?
11111111
01000000
00100000
00010000
00001000
00000100
00000010
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: 1002ms
memory: 5616kb

input:

10000
8
0
11111111
10111111
11011111
11110100
11111100
11111011
11110110
11110101
0
11110100
10111111
11111111
11010100
11011100
11111011
11010110
11010101
0
11111111
11110111
01111100
11101111
11111011
01111100
11111111
11111111
0
11111111
01111110
01110111
11111111
11111111
11111101
11101111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #29:

score: 0
Accepted
time: 956ms
memory: 5604kb

input:

10000
8
0
11111111
10111111
11011111
11111011
11110111
11111111
11111101
11111110
0
11111011
10111111
11011111
11110011
11111111
11110111
11111101
11111110
0
11111111
01111011
01111011
11101111
11111111
11111111
11111111
01111011
0
11111111
11111010
01110111
11111111
01111111
11101110
11101011
01110...

output:

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

result:

ok correct! (10000 test cases)

Test #30:

score: 0
Accepted
time: 941ms
memory: 5744kb

input:

10000
8
0
11111111
10111111
11101101
11011101
11110111
11001101
11001111
11111110
0
11001101
10111111
11101100
11011100
11110111
11001100
11001110
11111111
0
11111111
01111100
11101011
11011011
01111100
11111111
11111111
11001111
0
11111111
11111101
11111111
11111111
01101111
11111011
11110111
01111...

output:

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

result:

ok correct! (10000 test cases)

Test #31:

score: 0
Accepted
time: 944ms
memory: 5816kb

input:

10000
8
0
11111111
00111111
01011111
01101111
01110111
01111011
01111101
01111110
0
11111111
10111111
11011111
11101111
11110111
11111011
11111101
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
?
11111111
01000000
00100000
00010000
00001000
00000100
00000010
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: 1017ms
memory: 5756kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111101111
010000000
001000000
000100000
100010000
000001000
000000100
000000010
000000001
?
000000000
100001111
100001111
100001111
000010000
100001111
100001111
100001111
100001111
?
000000000
100000011
10...

result:

ok correct! (10000 test cases)

Test #33:

score: 0
Accepted
time: 1029ms
memory: 5680kb

input:

10000
9
0
111111111
111111111
010111111
011011111
011101111
011110111
011111011
011111101
011111110
0
101111111
111111111
110111111
111011111
111101111
111110111
111111011
111111101
111111110
0
111111111
111110000
011111111
101111111
101111111
011111111
101111111
101111111
011111111
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #34:

score: 0
Accepted
time: 1032ms
memory: 5808kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111101111
010000000
001000000
000100000
100010000
000001000
000000100
000000010
000000001
?
000000000
100001111
100001111
100001111
000010000
100001111
100001111
100001111
100001111
?
000000000
100000011
10...

result:

ok correct! (10000 test cases)

Test #35:

score: 0
Accepted
time: 1035ms
memory: 5828kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111111011
010000000
001000000
000100000
000010000
000001000
100000100
000000010
000000001
?
000000000
100001111
100001111
100001111
100001111
100001111
000000000
100001111
100001111
?
000000000
100000011
10...

result:

ok correct! (10000 test cases)

Test #36:

score: 0
Accepted
time: 1018ms
memory: 5824kb

input:

10000
9
0
111111111
111111011
110111111
111011111
111101111
111110111
111111111
111111101
111111110
0
111111011
111101011
110111111
111011111
111111111
111110111
111101111
111111101
111111110
0
111111111
101111111
111111111
111111111
011111011
111111111
111111111
011111011
011111011
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101111011
110000000
001000000
000100000
000010000
000001000
100000100
000000010
000000001
?
000000000
010000000
100001111
100001111
100001111
100001111
000000000
100001111
100001111
?
000000000
000000000
10...

result:

ok correct! (10000 test cases)

Test #37:

score: 0
Accepted
time: 324ms
memory: 4840kb

input:

10000
7
0
1111111
1011111
1111111
1110111
1111011
1111101
1111110
0
1111111
0011011
1111011
1110111
1111111
1111101
1111110
0
1111111
0111010
1111111
1111111
1111111
1111111
1111111
0
1111111
0010011
1111111
1111111
1111111
1111111
1111110
0
1111111
1100000
1111111
1111111
1111111
1111111
1111111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1101111
0100000
1010000
0001000
0000100
0000010
0000001
?
0000000
1111111
0000000
0000000
1111111
1111111
1111111
?
0000000
1111111
0000000
1000101
0000000
0000000
0111010
?
0000000
1111111
1000100
0000000
0000000
0101000
0000000
!
0000100
...

result:

ok correct! (10000 test cases)

Test #38:

score: 0
Accepted
time: 418ms
memory: 4692kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #39:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #40:

score: 0
Accepted
time: 413ms
memory: 4728kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #41:

score: 0
Accepted
time: 1049ms
memory: 5808kb

input:

10000
9
0
111111111
111110111
010111111
011011111
111111111
111111111
011111011
011111101
011111110
0
111110111
111110111
110111111
111011111
111111111
111111111
111111011
111111101
111111110
0
111111111
111111000
111111111
111111111
111111111
111111111
111111111
011110111
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101100111
110000000
001000000
000100000
100010000
100001000
000000100
000000010
000000001
?
000000000
010000000
100001111
100001111
000010000
000000000
100001111
100001111
100001111
?
000000000
000000000
10...

result:

ok correct! (10000 test cases)

Test #42:

score: 0
Accepted
time: 1047ms
memory: 5812kb

input:

10000
9
0
111111111
110111101
101111101
100111101
111101111
100111101
111111011
111111101
111111111
0
111101001
110111101
101111101
100111101
111101111
100111101
111111011
111111101
111111111
0
100111111
110110001
101110001
100110001
100111111
111111111
011111101
100111111
111111111
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100010110
110000000
101000000
100100000
000010000
100001000
000000100
000000010
100000001
?
100001111
010000000
001000000
000100000
100001111
000000000
100001111
100001111
000000000
?
100000011
000000000
00...

result:

ok correct! (10000 test cases)

Test #43:

score: 0
Accepted
time: 1014ms
memory: 5808kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110111011
010000000
101000000
000100000
000010000
000001000
100000100
000000010
000000001
?
100001111
100001111
001000000
100001111
100001111
100001111
000000000
100001111
100001111
?
100000011
100110000
00...

result:

ok correct! (10000 test cases)

Test #44:

score: 0
Accepted
time: 384ms
memory: 4648kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #45:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #46:

score: 0
Accepted
time: 419ms
memory: 4720kb

input:

10000
8
0
11111111
00111111
11111111
01101111
11111111
01111011
01111101
11111111
0
11111111
10111111
11111111
11101111
11111111
11111011
11111101
11111111
0
11111111
01111101
11111111
11111111
11111111
01111101
01111101
11111111
0
11111111
01111111
11111111
11111111
11111111
11111111
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #47:

score: 0
Accepted
time: 350ms
memory: 4844kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #48:

score: 0
Accepted
time: 997ms
memory: 5804kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111111010
010000000
001000000
000100000
000010000
000001000
100000100
000000010
100000001
?
000000000
100001111
100001111
100001111
100001111
100001111
000000000
100001111
000000000
?
000000000
100000011
10...

result:

ok correct! (10000 test cases)

Test #49:

score: 0
Accepted
time: 982ms
memory: 5752kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #50:

score: 0
Accepted
time: 1035ms
memory: 5756kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101001110
110000000
001000000
100100000
100010000
000001000
000000100
000000010
100000001
?
000000000
010000000
100001111
000100000
000010000
100001111
100001111
100001111
000000000
?
000000000
000000000
10...

result:

ok correct! (10000 test cases)

Test #51:

score: 0
Accepted
time: 191ms
memory: 4708kb

input:

10000
7
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
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
111111...

output:

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

result:

ok correct! (10000 test cases)

Test #52:

score: 0
Accepted
time: 263ms
memory: 4712kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
01111111
11111111
11111111
11111111
11111111
11111111
11111111
11111110
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
?
10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
?
10000111
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
10000001
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
10...

result:

ok correct! (10000 test cases)

Test #53:

score: 0
Accepted
time: 361ms
memory: 4656kb

input:

10000
8
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
11111110
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0...

output:

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

result:

ok correct! (10000 test cases)

Test #54:

score: 0
Accepted
time: 337ms
memory: 4764kb

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
11111111
11111111
11111111
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #55:

score: 0
Accepted
time: 174ms
memory: 4852kb

input:

10000
8
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
11111111
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
1...

output:

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

result:

ok correct! (10000 test cases)

Test #56:

score: 0
Accepted
time: 928ms
memory: 5828kb

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
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #57:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #58:

score: 0
Accepted
time: 555ms
memory: 5744kb

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
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #59:

score: 0
Accepted
time: 656ms
memory: 5804kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #60:

score: 0
Accepted
time: 902ms
memory: 5756kb

input:

10000
7
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
1111111
0
1111111
1111111
1101111
1111111
1111111
1111111
111111...

output:

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

result:

ok correct! (10000 test cases)

Test #61:

score: 0
Accepted
time: 928ms
memory: 5648kb

input:

10000
7
0
1111111
1011111
1111110
1110111
1111111
1111111
1111111
0
1111110
1111111
1111110
1110111
1111111
1111111
1111111
0
1111111
1111111
1101111
1111111
1111111
1111111
1111111
0
1111111
0111110
1111111
0111110
1111011
1111111
1111111
0
1111111
0111111
1111111
1111111
1111111
1111111
1111111
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #62:

score: 0
Accepted
time: 807ms
memory: 5612kb

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
111111111
111111111
111111111
111111111
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #63:

score: 0
Accepted
time: 409ms
memory: 5736kb

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
11111111
11111111
11111111
11111111
01111110
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #64:

score: 0
Accepted
time: 446ms
memory: 5824kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #65:

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

input:

10000
6
0
111111
101111
110111
111100
111101
111101
0
100101
101111
110111
111100
111101
111101
0
011100
011100
011100
111101
011100
111111
0
111100
011111
011111
111111
111100
111111
0
011111
111101
011111
111111
011111
111111
0
6
0
111111
001111
010111
011011
011101
011110
0
111111
101111
110111
1...

output:

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

result:

ok correct! (10000 test cases)

Test #66:

score: 0
Accepted
time: 355ms
memory: 4840kb

input:

10000
7
0
1111111
1110010
1101111
1111010
1111011
1111101
1110011
0
1110110
1110010
1101111
1111010
1111011
1111101
1110011
0
1111111
1011111
1110111
1111000
0111010
0111010
1111111
0
1111111
1111111
0111110
1111111
0110111
0110111
1111111
0
1111111
1111111
1101010
1111111
1111000
0111111
1111110
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #67:

score: 0
Accepted
time: 375ms
memory: 4856kb

input:

10000
7
0
1111111
0011111
0101111
0110111
1111101
1111111
0111110
0
0000110
1011111
1101111
1110111
1111101
1111111
1111110
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
0111110
0111110
0111110
0111110
0111101
1111111
0111110
0
0111101
0111101
0111101
0111101
1111111
1111111
0111101
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #68:

score: 0
Accepted
time: 388ms
memory: 4664kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #69:

score: 0
Accepted
time: 316ms
memory: 4708kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #70:

score: 0
Accepted
time: 322ms
memory: 4716kb

input:

10000
8
0
11111111
10111111
11011111
11111100
11110111
11111011
11111110
11111110
0
10010010
10111111
11011111
11111100
11110111
11111011
11111110
11111110
0
01111100
01111100
11111111
11101111
01111100
01111100
11111111
01111100
0
11111100
11111100
01111110
11111111
01111111
11111100
11100110
01111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11101101
01000000
00100000
10010000
00001000
00000100
10000010
00000001
?
10000111
10000111
10000111
00010000
10000111
10000111
00000000
10000111
?
10011000
10011000
10000001
00000000
10011000
10011000
00000010
10011000
?
10...

result:

ok correct! (10000 test cases)

Test #71:

score: 0
Accepted
time: 371ms
memory: 4772kb

input:

10000
8
0
11111111
10111111
11011111
11101111
11111111
11111011
11111101
11111110
0
11110111
11111111
11011111
11101111
10111111
11111011
11111101
11111110
0
11111111
01111111
11110111
11110111
11110111
11110111
01111111
01111111
0
11111111
11111110
01111111
01111111
11111111
11100111
01110111
01110...

output:

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

result:

ok correct! (10000 test cases)

Test #72:

score: 0
Accepted
time: 410ms
memory: 4696kb

input:

10000
8
0
11111111
11111111
11011111
11101111
11111111
11111011
11111111
11111111
0
11111111
11111111
11111111
11101111
11111111
11111111
11111111
11111111
0
11111111
10111111
01111000
01111000
11111111
01111000
11111111
11111111
0
11111111
11111111
01100111
01100111
11111111
01100111
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #73:

score: 0
Accepted
time: 406ms
memory: 4840kb

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: 395ms
memory: 4696kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #75:

score: 0
Accepted
time: 438ms
memory: 4840kb

input:

10000
8
0
11111111
10111101
11111101
11101101
11110101
11111001
11111111
11111100
0
11111101
00110001
11110001
01100001
01111001
01110101
11111111
01110000
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
?
11011101
01000000
10100000
00010000
00001000
00000100
10000010
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: 428ms
memory: 4788kb

input:

10000
8
0
11111111
00111111
01011111
11111111
01110111
01111011
11111111
11111111
0
11111111
00011111
01111111
11111111
11110111
01011011
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
?
11101100
01000000
00100000
10010000
00001000
00000100
10000010
10000001
?
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: 987ms
memory: 5808kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111011111
010000000
001000000
100100000
000010000
000001000
000000100
000000010
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: 1018ms
memory: 5804kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111011101
010000000
001000000
100100000
000010000
000001000
000000100
100000010
000000001
?
000000000
100001111
100001111
000100000
100001111
100001111
100001111
000000000
100001111
?
000000000
100110000
10...

result:

ok correct! (10000 test cases)

Test #79:

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

input:

10000
9
0
111111111
001111111
101111101
100111101
011101111
011110111
111111111
011111101
011111110
0
001100100
101111111
101111101
100111101
111101111
111110111
111111111
111111101
111111110
0
011111101
100111111
001110100
000110100
100111111
011111101
111111111
011111101
011111101
0
101111100
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110011011
010000000
101000000
100100000
000010000
000001000
100000100
000000010
000000001
?
100001111
100001111
001000000
000100000
100001111
100001111
000000000
100001111
100001111
?
100110000
100000011
00...

result:

ok correct! (10000 test cases)

Test #80:

score: 0
Accepted
time: 975ms
memory: 5664kb

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101110010
110000000
001000000
000100000
000010000
100001000
100000100
000000010
100000001
?
000000000
010000000
100001111
100001111
100001111
000000000
000000000
100001111
000000000
?
000000000
000000000
10...

result:

ok correct! (10000 test cases)

Extra Test:

score: 0
Extra Test Passed