QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#328179#7788. Rook DetectionAFewSunsAC ✓309ms5020kbC++144.2kb2024-02-15 17:55:032024-02-15 17:55:03

Judging History

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

  • [2024-02-15 17:55:03]
  • 评测
  • 测评结果:AC
  • 用时:309ms
  • 内存:5020kb
  • [2024-02-15 17:55:03]
  • 提交

answer

#include<bits/stdc++.h>
using namespace std;
namespace my_std{
	#define ll long long
	#define bl bool
	ll my_pow(ll a,ll b,ll mod){
		ll res=1;
		if(!b) return 1;
		while(b){
			if(b&1) res=(res*a)%mod;
			a=(a*a)%mod;
			b>>=1;
		}
		return res;
	}
	ll qpow(ll a,ll b){
		ll res=1;
		if(!b) return 1;
		while(b){
			if(b&1) res*=a;
			a*=a;
			b>>=1;
		}
		return res;
	}
	#define db double
	#define pf printf
	#define pc putchar
	#define fr(i,x,y) for(register ll i=(x);i<=(y);i++)
	#define pfr(i,x,y) for(register ll i=(x);i>=(y);i--)
	#define go(u) for(ll i=head[u];i;i=e[i].nxt)
	#define enter pc('\n')
	#define space pc(' ')
	#define fir first
	#define sec second
	#define MP make_pair
	#define il inline
	#define inf 8e18
	#define random(x) rand()*rand()%(x)
	#define inv(a,mod) my_pow((a),(mod-2),(mod))
	il ll read(){
		ll sum=0,f=1;
		char ch=0;
		while(!isdigit(ch)){
			if(ch=='-') f=-1;
			ch=getchar();
		}
		while(isdigit(ch)){
			sum=sum*10+(ch^48);
			ch=getchar();
		}
		return sum*f;
	}
	il void write(ll x){
		if(x<0){
			x=-x;
			pc('-');
		}
		if(x>9) write(x/10);
		pc(x%10+'0');
	}
	il void writeln(ll x){
		write(x);
		enter;
	}
	il void writesp(ll x){
		write(x);
		space;
	}
}
using namespace my_std;
#define fl fflush(stdout)
ll t,n,L[550],R[550];
bl ck[550][550],c1[550][550],c2[550][550],ans[550][550];
bl nd[550],vis[550],ban[550];
char s[550];
il void query(){
	pf("?\n");
	fr(i,1,n){
		fr(j,1,n) write(ck[i][j]);
		enter;
	}
	fl;
	ll tmp=read();
	fr(i,1,n){
		scanf("%s",s+1);
		fr(j,1,n) ck[i][j]=s[j]-'0';
	}
}
il void clr(){
	fr(i,1,n) nd[i]=vis[i]=ban[i]=0;
	fr(i,1,n) fr(j,1,n) ck[i][j]=c1[i][j]=c2[i][j]=ans[i][j]=0;
}
il void report(){
	pf("!\n");
	fr(i,1,n){
		fr(j,1,n) write(ans[i][j]);
		enter;
	}
	fl;
	ll tmp=read();
	clr();
}
il void solve1(ll x){
	fr(i,1,n){
		L[i]=1;
		R[i]=n;
	}
	while(1){
		bl pd=0;
		fr(i,1,n) fr(j,1,n) ck[i][j]=0;
		fr(i,1,n){
			if(L[i]<R[i]){
				pd=1;
				ll mid=(L[i]+R[i])/2;
				fr(j,L[i],mid) ck[j][i]=1;
			}
		}
		if(!pd) break;
		fr(i,1,n) ck[x][i]=1;
		query();
		fr(i,1,n){
			if(L[i]<R[i]){
				ll mid=(L[i]+R[i])/2;
				if(ck[x][i]) R[i]=mid;
				else L[i]=mid+1;
			}
		}
	}
	fr(i,1,n) ans[L[i]][i]=1;
	report();
}
il void solve2(){
	fr(i,1,n) fr(j,1,n) ck[i][j]=0;
	fr(i,2,n) ck[i][i]=1;
	query();
	fr(i,2,n){
		if(ck[i][i]) ans[i][i]=1;
		else ans[i][1]=1;
	}
	ll l=1,r=n;
	while(l<r){
		ll mid=(l+r)>>1;
		fr(i,1,n) fr(j,1,n) ck[i][j]=0;
		fr(i,1,mid) ck[1][i]=1;
		query();
		if(ck[1][1]) r=mid;
		else l=mid+1;
	}
	ans[1][l]=1;
	report();
}
il void solve3(){
	fr(i,1,n){
		L[i]=1;
		R[i]=n;
	}
	while(1){
		bl pd=0;
		fr(i,1,n) fr(j,1,n) ck[i][j]=0;
		fr(i,1,n) ban[i]=0;
		fr(i,1,n){
			if(!nd[i]||L[i]>=R[i]) continue;
			pd=1;
			ll mid=(L[i]+R[i])/2;
			fr(j,L[i],mid) ck[i][j]=ban[j]=1;
			ck[i][1]=1;
		}
		fr(i,1,n) if(!nd[i]&&!vis[i]&&!ban[i]) ck[i][i]=pd=1;
		if(!pd) break;
		query();
		fr(i,1,n){
			if(!nd[i]||L[i]>=R[i]) continue;
			ll mid=(L[i]+R[i])/2;
			if(ck[i][1]) R[i]=mid;
			else L[i]=mid+1;
		}
		fr(i,1,n){
			if(!nd[i]&&!vis[i]&&!ban[i]){
				if(ck[i][i]) ans[i][i]=1;
				else ans[i][1]=1;
				vis[i]=1;
			}
		}
	}
	fr(i,1,n) if(nd[i]) ans[i][L[i]]=1;
	report();
}
int main(){
	t=read();
	while(t--){
		n=read();
		fr(i,1,n) fr(j,1,n) ck[i][j]=0;
		fr(i,2,n) ck[i][1]=ck[i][i]=1;
		query();
		fr(i,1,n) fr(j,1,n) c1[i][j]=ck[i][j];
		if(!c1[1][1]){
			solve1(1);
			continue;
		}
		bl pd=0;
		fr(i,1,n) if(!c1[i][i]) pd=1;
		if(!pd){
			solve2();
			continue;
		}
		fr(i,1,n) fr(j,1,n) ck[i][j]=0;
		ck[1][1]=1;
		fr(i,2,n){
			if(!c1[i][i]) ck[i][i]=ck[1][i]=1;
			else ck[i][1]=1;
		}
		query();
		fr(i,1,n) fr(j,1,n) c2[i][j]=ck[i][j];
		pd=0;
		fr(i,2,n){
			if(!c1[i][i]&&!c2[i][1]){
				solve1(i);
				pd=1;
				break;
			}
		}
		if(pd) continue;
		fr(i,2,n) if(!c1[i][i]&&c2[i][i]) ans[1][i]=pd=1;
		if(!pd){
			fr(i,2,n) if(!c1[i][i]&&c2[1][i]) ans[1][1]=1;
		}
		pd=0;
		fr(i,1,n) if(ans[1][i]) pd=1;
		if(!pd) nd[1]=1;
		else vis[1]=1;
		fr(i,2,n) if(!c1[i][i]) nd[i]=1;
		solve3();
	}
}
/*
2
5
10110
00100
01000
00000
00001
5
01000
00010
01000
10000
10010
*/

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

詳細信息

Test #1:

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

input:

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

output:

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

result:

ok correct! (1 test case)

Test #2:

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

input:

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

output:

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

result:

ok correct! (9898 test cases)

Test #3:

score: 0
Accepted
time: 85ms
memory: 3888kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #4:

score: 0
Accepted
time: 86ms
memory: 3904kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #5:

score: 0
Accepted
time: 62ms
memory: 3832kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #6:

score: 0
Accepted
time: 73ms
memory: 3888kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #7:

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

input:

7368
4
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
4
0
1111
1111
1111
1111
0
1111
1011
1111
1111
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
4
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
0111
1111
1111
1111
0
4
0
1111
1111
1111
...

output:

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

result:

ok correct! (7368 test cases)

Test #8:

score: 0
Accepted
time: 207ms
memory: 4960kb

input:

10000
9
0
111111111
101111111
110111111
111111111
111101111
111110111
111111111
111111111
111111111
0
111111111
111111111
110111111
111111111
111101111
111110111
111111111
111111111
111111111
0
111111111
111111110
000111111
111111111
000111111
111111111
111111011
111111101
111111111
0
111111111
0001...

output:

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

result:

ok correct! (10000 test cases)

Test #9:

score: 0
Accepted
time: 176ms
memory: 4892kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #10:

score: 0
Accepted
time: 184ms
memory: 4972kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100110000
100000000
100000000
000100000
000010000
100000000
100000000
100000000
100000000
?
000000000
000000000
000000000
111110000
111110000
000001000
000000100
000000010
000000001
?
000000000
000000000
00...

result:

ok correct! (10000 test cases)

Test #11:

score: 0
Accepted
time: 168ms
memory: 4976kb

input:

10000
4
0
1111
1111
1111
1111
0
1111
1011
1111
1111
0
1111
1111
1111
1111
0
1111
1111
1111
1111
0
6
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
111111
111111
111111
0
111111
111111
111111
1...

output:

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

result:

ok correct! (10000 test cases)

Test #12:

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

input:

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

output:

?
000000
110000
101000
100100
100010
100001
?
000000
010000
001000
000100
000010
000001
?
111000
000000
000000
000000
000000
000000
?
110000
000000
000000
000000
000000
000000
?
100000
000000
000000
000000
000000
000000
!
100000
010000
001000
000100
000010
000001
?
000000000
110000000
101000000
1001...

result:

ok correct! (10000 test cases)

Test #13:

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

input:

10000
6
0
111111
101111
110111
111011
100010
111110
0
111111
101111
110111
111011
100010
111110
0
111111
000111
000111
000111
111101
000111
0
111111
100110
100110
100110
111111
100110
0
111111
011011
011011
011011
111111
011011
0
8
0
11111111
11000110
10100110
11101111
10001110
11111011
10000110
111...

output:

?
000000
110000
101000
100100
100010
100001
?
111101
010000
001000
000100
100000
000001
?
000000
111000
111000
111000
000010
111000
?
000000
100110
100110
100110
000000
100110
?
000000
100100
100100
100100
000000
100100
!
100000
000010
000010
000010
100000
000010
?
00000000
11000000
10100000
1001000...

result:

ok correct! (10000 test cases)

Test #14:

score: 0
Accepted
time: 166ms
memory: 4748kb

input:

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

output:

?
000000
110000
101000
100100
100010
100001
?
111111
010000
001000
000100
000010
000001
?
111111
111111
111111
000000
000000
000000
?
111111
111111
000000
000000
000000
000000
?
111010
111111
000000
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: 142ms
memory: 4888kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100001101
100000000
100000000
100000000
100000000
000001000
000000100
100000000
000000001
?
111111111
111111111
111111111
111111111
111111111
000000000
111111111
000000000
000000000
?
111111111
111111111
11...

result:

ok correct! (10000 test cases)

Test #16:

score: 0
Accepted
time: 145ms
memory: 4824kb

input:

10000
7
0
1111111
1111111
1010000
1111111
1111111
1111111
1111111
0
1111111
1011111
1111111
1110111
1111011
1111101
1111110
0
1111000
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #17:

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

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111011111
111111111
111111111
111111111
111111111
111111110
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #18:

score: 0
Accepted
time: 224ms
memory: 4944kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #19:

score: 0
Accepted
time: 208ms
memory: 4912kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #20:

score: 0
Accepted
time: 252ms
memory: 4980kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #21:

score: 0
Accepted
time: 205ms
memory: 4912kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #22:

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

input:

10000
9
0
111111111
111111111
111111111
100101000
111111111
100001000
111111111
111111111
111111111
0
111111111
101111111
110111111
111011111
111101111
111111111
111111011
111111101
111111110
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #23:

score: 0
Accepted
time: 236ms
memory: 4896kb

input:

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

output:

?
000000
110000
101000
100100
100010
100001
?
100111
100000
100000
000100
000010
000001
?
111111
111111
111111
111111
000000
000000
?
111111
111111
000000
111111
000000
000000
?
111111
000000
000000
111111
000000
000000
!
111111
000000
000000
000000
000000
000000
?
0000000
1100000
1010000
1001000
10...

result:

ok correct! (10000 test cases)

Test #24:

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

input:

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

output:

?
00000
11000
10100
10010
10001
?
11111
01000
00100
00010
00001
?
00000
11100
11100
11100
11100
?
00000
11000
11000
10010
10010
?
00000
00000
10000
00000
00000
!
10000
00100
01000
00001
00010
?
00000
11000
10100
10010
10001
?
11110
01000
00100
00010
10000
?
00000
11100
11100
11100
00001
?
00000
1100...

result:

ok correct! (10000 test cases)

Test #25:

score: 0
Accepted
time: 143ms
memory: 4388kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #26:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #27:

score: 0
Accepted
time: 252ms
memory: 4968kb

input:

10000
8
0
11111111
00111111
01011111
01101111
01110111
01111011
01111101
01111110
0
11111111
10111111
11011111
11101111
11110111
11111011
11111101
11111110
0
11111111
01111111
01111111
11111111
01111111
11111111
01111111
11111111
0
11111111
01111111
10111111
11110011
01111111
01111111
10111111
01111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11111111
01000000
00100000
00010000
00001000
00000100
00000010
00000001
?
00000000
11110000
11110000
11110000
11110000
11110000
11110000
11110000
?
00000000
10001100
10001100
11000000
10001100
11000000
10001100
11000000
?
00...

result:

ok correct! (10000 test cases)

Test #28:

score: 0
Accepted
time: 217ms
memory: 4972kb

input:

10000
8
0
11111111
10111111
11011111
11110100
11111100
11111011
11110110
11110101
0
11111111
10111111
11111111
11011111
11111111
11111011
11111111
11111111
0
11111111
01011111
11110100
11111111
10101100
11110100
10100110
10100101
0
11111111
10111111
11111011
11101111
11111111
01111111
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #29:

score: 0
Accepted
time: 210ms
memory: 4900kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #30:

score: 0
Accepted
time: 239ms
memory: 4964kb

input:

10000
8
0
11111111
10111111
11101101
11011101
11110111
11001101
11001111
11111110
0
11111111
10111111
11111111
11111111
11110111
11111110
11111111
11111111
0
11111111
01001111
11111111
11111111
11111101
11111011
10111111
01001111
0
11111111
10001111
10100011
10010011
11000011
11111111
11111111
10001...

output:

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

result:

ok correct! (10000 test cases)

Test #31:

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

input:

10000
8
0
11111111
00111111
01011111
01101111
01110111
01111011
01111101
01111110
0
11111111
10111111
11011111
11101111
11110111
11111011
11111101
11111110
0
11111111
11111111
01111111
01111111
11111111
01111111
01111111
11111111
0
11111111
01111111
01111111
01111111
11110011
10111111
10111111
01111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11111111
01000000
00100000
00010000
00001000
00000100
00000010
00000001
?
00000000
11110000
11110000
11110000
11110000
11110000
11110000
11110000
?
00000000
11000000
10001100
10001100
11000000
10001100
10001100
11000000
?
00...

result:

ok correct! (10000 test cases)

Test #32:

score: 0
Accepted
time: 286ms
memory: 4912kb

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
001111111
001111111
111111111
111111111
001111111
111111111
111111111
001111111
0
111111111
1101...

output:

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

result:

ok correct! (10000 test cases)

Test #33:

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

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101111111
100000000
001000000
000100000
000010000
000001000
000000100
000000010
000000001
?
000000000
000000000
111110000
111110000
111110000
111110000
111110000
111110000
111110000
?
000000000
000000000
11...

result:

ok correct! (10000 test cases)

Test #34:

score: 0
Accepted
time: 296ms
memory: 4896kb

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
011011111
111111111
111111111
111111111
011011111
011011111
111111111
011011111
0
111111111
1001...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111101111
010000000
001000000
000100000
100000000
000001000
000000100
000000010
000000001
?
000000000
111110000
111110000
111110000
000000000
111110000
111110000
111110000
111110000
?
000000000
100001100
11...

result:

ok correct! (10000 test cases)

Test #35:

score: 0
Accepted
time: 239ms
memory: 4964kb

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
001111111
111111111
001111111
111111111
111111111
111111011
001111111
001111111
0
111111111
0111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
111111011
010000000
001000000
000100000
000010000
000001000
100000000
000000010
000000001
?
000000000
111110000
111110000
111110000
111110000
111110000
000000100
111110000
111110000
?
000000000
100001100
11...

result:

ok correct! (10000 test cases)

Test #36:

score: 0
Accepted
time: 279ms
memory: 4896kb

input:

10000
9
0
111111111
111111011
110111111
111011111
111101111
111110111
111111111
111111101
111111110
0
111111111
111101111
110111111
111011111
111111111
111110111
111111111
111111101
111111110
0
111111111
111111111
011101111
011101111
111111011
011101111
100011111
111111011
111111011
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #37:

score: 0
Accepted
time: 157ms
memory: 4412kb

input:

10000
7
0
1111111
1011111
1111111
1110111
1111011
1111101
1111110
0
1111111
0011011
1111111
1110111
1111111
1111101
1111110
0
1111111
1010101
1111111
1111111
1111111
1111111
1111111
0
1010111
0111100
1111111
1111111
1111011
1111111
1111111
0
0110111
1011100
1111111
1111111
0111011
1111111
1111111
0
...

output:

?
0000000
1100000
1010000
1001000
1000100
1000010
1000001
?
1101111
0100000
1000000
0001000
0000100
0000010
0000001
?
1111111
1111111
1111111
1111111
0000000
0000000
0000000
?
1010101
1111111
0000000
0000000
0101010
0101010
0000000
?
0010100
1111111
1000001
0000000
0101000
0000000
0000000
!
0010100
...

result:

ok correct! (10000 test cases)

Test #38:

score: 0
Accepted
time: 113ms
memory: 4444kb

input:

10000
8
0
11111111
10111111
11111111
11111111
11110111
11111011
11111101
11111110
0
11111111
11111111
11111111
11111111
11110111
11111011
11111101
11111110
0
11111111
11111111
11111111
11111111
00111111
00111111
11111111
00111111
0
11111111
00111111
11011111
11111011
11111111
01110111
00111111
01110...

output:

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

result:

ok correct! (10000 test cases)

Test #39:

score: 0
Accepted
time: 164ms
memory: 4376kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #40:

score: 0
Accepted
time: 116ms
memory: 4388kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #41:

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

input:

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101100111
100000000
001000000
000100000
100000000
100000000
000000100
000000010
000000001
?
000000000
000000000
111110000
111110000
000000000
000001000
111110000
111110000
111110000
?
000000000
000000000
10...

result:

ok correct! (10000 test cases)

Test #42:

score: 0
Accepted
time: 228ms
memory: 4952kb

input:

10000
9
0
111111111
110111101
101111101
100111101
111101111
100111101
111111011
111111101
111111111
0
111101001
111111111
111111111
111111111
111101111
111111101
111111011
111111101
111111111
0
000011111
111111111
111111111
111111111
000011111
111110111
111111101
000011111
111111111
0
011111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100010110
100000000
100000000
100000000
000010000
100000000
000000100
000000010
100000000
?
111110000
000000000
000000000
000000000
111110000
000001000
111110000
111110000
000000001
?
100001100
000000000
00...

result:

ok correct! (10000 test cases)

Test #43:

score: 0
Accepted
time: 210ms
memory: 4952kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110111011
010000000
100000000
000100000
000010000
000001000
100000000
000000010
000000001
?
111110000
111110000
000000000
111110000
111110000
111110000
000000100
111110000
111110000
?
111000000
111000000
00...

result:

ok correct! (10000 test cases)

Test #44:

score: 0
Accepted
time: 128ms
memory: 4360kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #45:

score: 0
Accepted
time: 163ms
memory: 4428kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #46:

score: 0
Accepted
time: 100ms
memory: 4392kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #47:

score: 0
Accepted
time: 113ms
memory: 4456kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #48:

score: 0
Accepted
time: 309ms
memory: 4912kb

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

output:

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

result:

ok correct! (10000 test cases)

Test #49:

score: 0
Accepted
time: 265ms
memory: 4900kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111101111
111110111
111111011
111111111
111111111
0
111111111
111111111
111111111
111111111
111101111
111110111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111101
111111101
011101111
111111111
111111110
0
111111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100011100
100000000
100000000
100000000
000010000
000001000
000000100
100000000
100000000
?
000000000
000000000
000000000
000000000
111110000
111110000
111110000
000000010
000000001
?
000000000
000000000
00...

result:

ok correct! (10000 test cases)

Test #50:

score: 0
Accepted
time: 251ms
memory: 5020kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101001110
100000000
001000000
100000000
100000000
000001000
000000100
000000010
100000000
?
000000000
000000000
111110000
000000000
000000000
111110000
111110000
111110000
000000001
?
000000000
000000000
11...

result:

ok correct! (10000 test cases)

Test #51:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #52:

score: 0
Accepted
time: 76ms
memory: 4428kb

input:

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

result:

ok correct! (10000 test cases)

Test #53:

score: 0
Accepted
time: 136ms
memory: 4392kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
11011111
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
?
00000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
?
11110000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
11000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
10...

result:

ok correct! (10000 test cases)

Test #54:

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

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
00111111
11111111
11111111
11111111
11111110
0
11111111
00111111
11111111
11111111
11111111
11111111
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #55:

score: 0
Accepted
time: 120ms
memory: 4452kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111
0
11111111
10111111
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
?
00000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
?
11110000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
11000000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
10...

result:

ok correct! (10000 test cases)

Test #56:

score: 0
Accepted
time: 286ms
memory: 4980kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100100000
100000000
100000000
000100000
100000000
100000000
100000000
100000000
100000000
?
000000000
000000000
000000000
111110000
000000000
000001000
000000100
000000010
000000001
?
000000000
010000000
00...

result:

ok correct! (10000 test cases)

Test #57:

score: 0
Accepted
time: 250ms
memory: 5012kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #58:

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

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
100001000
100000000
100000000
100000000
100000000
000001000
100000000
100000000
100000000
?
000000000
000000000
000000000
000000000
000000000
111110000
000000100
000000010
000000001
?
000000000
000000000
00...

result:

ok correct! (10000 test cases)

Test #59:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #60:

score: 0
Accepted
time: 218ms
memory: 4976kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #61:

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

input:

10000
7
0
1111111
1011111
1111110
1110111
1111111
1111111
1111111
0
1111111
1111111
1111111
1110111
1111111
1111111
1111111
0
1111111
1111111
1111111
0011111
1111011
1111111
1111111
0
1111111
0011111
1101111
1111111
1111111
1111111
1111111
0
1111111
1111111
1111111
1111111
1111111
1111111
1111111
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #62:

score: 0
Accepted
time: 246ms
memory: 4976kb

input:

10000
9
0
111111111
101111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
111111111
0
111111111
111111111
111111111
111111111
111111111
111110111
111111111
111111111
111111111
0
111111111
0001...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110000000
010000000
100000000
100000000
100000000
100000000
100000000
100000000
100000000
?
000000000
111110000
000000000
000000000
000000000
000001000
000000100
000000010
000000001
?
000000000
111000000
00...

result:

ok correct! (10000 test cases)

Test #63:

score: 0
Accepted
time: 252ms
memory: 4984kb

input:

10000
8
0
11111111
11111111
11111111
11111111
11111111
11111011
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
00111111
11111111
11111...

output:

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

result:

ok correct! (10000 test cases)

Test #64:

score: 0
Accepted
time: 277ms
memory: 4952kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110111001
010000000
100000000
000100000
000010000
000001000
100000000
100000000
000000001
?
000000000
111110000
000000000
111110000
111110000
111110000
000000100
000000010
111110000
?
000000000
111000000
00...

result:

ok correct! (10000 test cases)

Test #65:

score: 0
Accepted
time: 166ms
memory: 4788kb

input:

10000
6
0
111111
101111
110111
111100
111101
111101
0
100101
101111
110111
111111
111101
111111
0
011111
111100
111100
100100
011111
111111
0
101111
011111
111101
111111
101111
111111
0
111101
111111
011111
111111
111101
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
100000
000010
100000
?
111000
111000
111000
000100
111000
000001
?
100110
110000
110000
000000
100110
000000
?
100100
000000
100000
000000
100100
000000
!
000100
001000
010000
000100
000100
000001
?
000000
110000
101000
100100
100010...

result:

ok correct! (10000 test cases)

Test #66:

score: 0
Accepted
time: 118ms
memory: 4444kb

input:

10000
7
0
1111111
1110010
1101111
1111010
1111011
1111101
1110011
0
1111110
1111010
1101111
1111111
1111011
1111101
1111010
0
1111111
1111111
0110111
1111111
1111010
1111010
1111110
0
1111111
1111111
1010110
1011000
0111111
1110000
1111111
0
1111111
1011111
0111011
1111111
1111010
0111111
1111111
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #67:

score: 0
Accepted
time: 125ms
memory: 4424kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #68:

score: 0
Accepted
time: 145ms
memory: 4424kb

input:

10000
7
0
1111111
0011111
0101111
0110111
0111011
0111101
0111110
0
1111111
1111111
1101111
1110111
1111111
1111101
1111111
0
1111111
1111101
1111101
1111101
1111101
1111101
1111101
0
1111111
0011111
0011111
0011111
0011111
0011111
0011111
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
1111000
1111000
1111000
1111000
1111000
1111000
?
0000000
1100000
1100000
1100000
1100000
1100000
1100000
?
0000000
1010000
1010000
1010000
1010000
1010000
1010000
!
0100101
...

result:

ok correct! (10000 test cases)

Test #69:

score: 0
Accepted
time: 134ms
memory: 4380kb

input:

10000
7
0
1111111
1011111
1101111
1001111
1111011
1001111
1111110
0
1001010
1011111
1101111
1001111
1111011
1111111
1111110
0
0001111
1111111
0001111
1111111
0001111
1000111
0001111
0
1001111
0011111
0111111
1110111
1001111
1111111
1001111
0
0111111
0101111
1111111
1111111
0111111
1111111
1001111
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #70:

score: 0
Accepted
time: 157ms
memory: 4432kb

input:

10000
8
0
11111111
10111111
11011111
11111100
11110111
11111011
11111110
11111110
0
10010010
10111111
11011111
11111110
11110111
11111011
11111111
11111110
0
11111100
01111111
01111111
11111111
11111100
11111100
10001110
11111100
0
01111111
10111110
10111110
11101111
01111111
01111111
11111111
11110...

output:

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

result:

ok correct! (10000 test cases)

Test #71:

score: 0
Accepted
time: 154ms
memory: 4392kb

input:

10000
8
0
11111111
10111111
11011111
11101111
11111111
11111011
11111101
11111110
0
11110111
11111111
11011111
11101111
10110111
11111011
11111101
11111110
0
11111111
11110111
00111111
00111111
11110111
00111111
11110111
11110111
0
11111111
00111111
11111111
01110111
11111111
01110111
00111111
00111...

output:

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

result:

ok correct! (10000 test cases)

Test #72:

score: 0
Accepted
time: 156ms
memory: 4432kb

input:

10000
8
0
11111111
11111111
11011111
11101111
11111111
11111011
11111111
11111111
0
11111111
11111111
11111111
11101111
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
?
10110100
10000000
00100000
00010000
10000000
00000100
10000000
10000000
?
00000000
00000000
11110000
11110000
00001000
11110000
00000010
00000001
?
00000000
00000000
11000000
11000000
00000000
11000000
00000000
00000000
?
00...

result:

ok correct! (10000 test cases)

Test #73:

score: 0
Accepted
time: 155ms
memory: 4424kb

input:

10000
8
0
01011111
10011111
11111111
11001111
11110111
11011111
11011101
11011110
0
01111110
01111110
11111111
01111110
11111111
11111111
10010001
10010001
0
10000001
00000000
11111111
01111110
11111111
11111111
01111110
01111110
0
01111111
10010000
11111110
10010000
11111111
11111111
10010000
10010...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11111111
11111111
11111111
11111111
00000000
00000000
00000000
00000000
?
11111111
01111110
00000000
00000000
10000001
10000001
00000000
00000000
?
11111111
00000000
01111110
00000000
10000001
00000000
00000000
00000000
!
00...

result:

ok correct! (10000 test cases)

Test #74:

score: 0
Accepted
time: 126ms
memory: 4440kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #75:

score: 0
Accepted
time: 142ms
memory: 4428kb

input:

10000
8
0
11111111
10111101
11111101
11101101
11110101
11111001
11111111
11111100
0
11111111
00110011
11110011
01100011
01111011
01110111
11111111
01110010
0
11111111
10001100
11111111
10001100
01110011
01110011
11111111
01110011
0
11111111
00001100
11111111
11110011
10000000
10000000
11111111
11110...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11011101
01000000
10000000
00010000
00001000
00000100
10000000
00000001
?
11111111
11111111
11111111
11111111
00000000
00000000
00000000
00000000
?
10001100
11111111
00000000
00000000
01110011
01110011
00000000
00000000
?
00...

result:

ok correct! (10000 test cases)

Test #76:

score: 0
Accepted
time: 159ms
memory: 4388kb

input:

10000
8
0
11111111
00111111
01011111
11111111
01110111
01111011
11111111
11111111
0
11111111
00011111
01111111
11111111
11110111
01011011
11111111
11111111
0
11111111
10111001
10111001
11111111
11111111
01011111
11111111
11111111
0
11111111
11100110
01011111
11111111
01011111
01011111
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11101100
01000000
00100000
10000000
00001000
00000100
10000000
10000000
?
11111111
11111111
11111111
11111111
00000000
00000000
00000000
00000000
?
10111001
11111111
00000000
00000000
01000110
01000110
00000000
00000000
?
10...

result:

ok correct! (10000 test cases)

Test #77:

score: 0
Accepted
time: 262ms
memory: 4976kb

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
010101111
010101111
111111111
111111111
111111111
010101111
010101111
010101111
0
111111111
0111...

output:

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

result:

ok correct! (10000 test cases)

Test #78:

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

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

output:

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

result:

ok correct! (10000 test cases)

Test #79:

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

input:

10000
9
0
111111111
001111111
101111101
100111101
011101111
011110111
111111111
011111101
011111110
0
001100100
101111111
011111111
011111111
111101111
111110111
011111111
111111101
111111110
0
111111101
000101111
111111111
111111111
000101111
111111101
111111111
111111101
111111101
0
000111111
1111...

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
110011011
010000000
100000000
100000000
000010000
000001000
100000000
000000010
000000001
?
111110000
111110000
000000000
000000000
111110000
111110000
000000100
111110000
111110000
?
111000000
100001100
00...

result:

ok correct! (10000 test cases)

Test #80:

score: 0
Accepted
time: 255ms
memory: 4884kb

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

output:

?
000000000
110000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
?
101110010
100000000
001000000
000100000
000010000
100000000
100000000
000000010
100000000
?
000000000
000000000
111110000
111110000
111110000
000001000
000000100
111110000
000000001
?
000000000
000000000
11...

result:

ok correct! (10000 test cases)

Extra Test:

score: 0
Extra Test Passed