QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#329418#7788. Rook Detectionyz_lyAC ✓951ms5948kbC++144.9kb2024-02-16 17:32:522024-02-16 17:32:53

Judging History

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

  • [2024-02-16 17:32:53]
  • 评测
  • 测评结果:AC
  • 用时:951ms
  • 内存:5948kb
  • [2024-02-16 17:32:52]
  • 提交

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];
pair<int,int> q[505];
vector<pair<int,int> > ans;
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){
			ans.clear();
			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.emplace_back(make_pair(i,i));
				else
					ans.emplace_back(make_pair(i,1));
			}
			if(d[1][1])
				ans.emplace_back(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.emplace_back(make_pair(1,l));
			}
			init();
			for(auto i:ans){
				c[i.first][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;
		}/*否则每行都有,直接二分*/
		ans.clear();
		vector<int> gg;
		for(int i=2;i<=n;i++){
			if(c[1][i]){
				if(d[i][i]){
					ans.emplace_back(1,i);
					ff=1;
				}
				id[++cnt]=i;
			}
			else
				gg.emplace_back(i);
		}
		if(!ff){
			for(int i=2;i<=n;i++){
				if(c[1][i]&&d[1][i]){
					ans.emplace_back(1,1);
					ff=1;
					break;
				}
			}
			if(!ff)
				id[++cnt]=1;
		}
		for(int i=1;i<=cnt;i++){
			q[i]=make_pair(2,n);
		}
		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;
			}
			vector<int> hh,bb;
			for(auto i:gg){
				int flag=0;
				for(int j=1;j<=n;j++){
					if(c[j][i])
						flag=1;
				}
				if(!flag){
					c[i][i]=1;
					bb.emplace_back(i);
				}
				else
					hh.emplace_back(i);
			}
			gg=hh;
			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(auto i:bb){
				if(d[i][i])
					ans.emplace_back(make_pair(i,i));
				else
					ans.emplace_back(make_pair(i,1));
			}
		}
		if(gg.size()){
			init();
			for(auto i:gg){
				c[i][i]=1;
			}
			ask();
			receive();
			for(auto i:gg){
				if(d[i][i])
					ans.emplace_back(make_pair(i,i));
				else
					ans.emplace_back(make_pair(i,1));
			}
		}
		init();
		for(int i=1;i<=cnt;i++){
			c[id[i]][q[i].first]=1;
		}
		for(auto i:ans){
			c[i.first][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: 3636kb

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: 59ms
memory: 3684kb

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: 70ms
memory: 3964kb

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: 71ms
memory: 3688kb

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: 73ms
memory: 3748kb

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: 78ms
memory: 3688kb

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: 659ms
memory: 5664kb

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: 570ms
memory: 5620kb

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: 439ms
memory: 5536kb

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: 531ms
memory: 5568kb

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: 526ms
memory: 5648kb

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: 228ms
memory: 5512kb

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: 383ms
memory: 5664kb

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: 350ms
memory: 5328kb

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: 416ms
memory: 5448kb

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: 293ms
memory: 5584kb

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: 360ms
memory: 5416kb

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: 800ms
memory: 5672kb

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: 746ms
memory: 5720kb

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: 615ms
memory: 5668kb

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: 659ms
memory: 5896kb

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: 774ms
memory: 5716kb

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: 540ms
memory: 5928kb

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

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: 342ms
memory: 4680kb

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: 305ms
memory: 4692kb

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: 836ms
memory: 5648kb

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: 814ms
memory: 5920kb

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: 854ms
memory: 5608kb

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: 814ms
memory: 5708kb

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: 797ms
memory: 5920kb

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: 906ms
memory: 5920kb

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: 778ms
memory: 5648kb

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: 880ms
memory: 5660kb

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: 887ms
memory: 5924kb

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: 809ms
memory: 5656kb

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: 335ms
memory: 4700kb

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: 359ms
memory: 4948kb

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: 405ms
memory: 4680kb

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: 371ms
memory: 4648kb

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: 885ms
memory: 5920kb

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: 938ms
memory: 5628kb

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: 905ms
memory: 5712kb

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: 272ms
memory: 4688kb

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: 333ms
memory: 4700kb

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: 327ms
memory: 4924kb

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: 354ms
memory: 4648kb

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: 951ms
memory: 5644kb

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: 856ms
memory: 5916kb

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: 864ms
memory: 5652kb

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: 143ms
memory: 4692kb

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

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: 276ms
memory: 4688kb

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: 300ms
memory: 4700kb

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: 195ms
memory: 4764kb

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: 811ms
memory: 5680kb

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: 796ms
memory: 5936kb

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: 462ms
memory: 5932kb

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: 605ms
memory: 5668kb

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: 739ms
memory: 5612kb

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: 807ms
memory: 5728kb

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: 690ms
memory: 5620kb

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: 320ms
memory: 5948kb

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: 311ms
memory: 5648kb

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: 557ms
memory: 5328kb

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: 309ms
memory: 4964kb

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: 327ms
memory: 4700kb

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: 344ms
memory: 4740kb

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: 335ms
memory: 4748kb

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: 364ms
memory: 4756kb

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: 380ms
memory: 4648kb

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: 402ms
memory: 4964kb

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: 324ms
memory: 4924kb

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: 351ms
memory: 4708kb

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: 365ms
memory: 4684kb

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: 341ms
memory: 4748kb

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: 880ms
memory: 5604kb

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: 860ms
memory: 5648kb

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: 839ms
memory: 5664kb

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: 811ms
memory: 5608kb

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