QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#344977#7788. Rook DetectionGuanYunchangAC ✓874ms7808kbC++174.4kb2024-03-05 21:42:012024-03-05 21:42:01

詳細信息

Test #1:

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

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: 115ms
memory: 5784kb

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
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
011
111
110
0
111
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
?
110
000
000
!
010
100
001
?
000
110
101
?
100
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
010
100
!
001
010
010
?
000
110
101
?
100
...

result:

ok correct! (9898 test cases)

Test #3:

score: 0
Accepted
time: 90ms
memory: 5724kb

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: 83ms
memory: 5784kb

input:

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

output:

?
0000
1100
1010
1001
?
1000
0100
0010
0001
?
1110
0000
0000
0000
?
1100
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
?
1000
0100
0010
0001
?
1110
0000
0000
0000
?
1100
0000
00...

result:

ok correct! (10000 test cases)

Test #5:

score: 0
Accepted
time: 115ms
memory: 5784kb

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
1111
0011
1110
0
1111
1011
0101
1111
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
0001
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
1000
0010
1000
?
0000
0000
1100
0001
?
0000
0100
1010
0000
!
0010
1000
0001
1000
?
0000
1100
1010
1001
?
1000
0100
0010
0001
!
1000
1000
0010
1000
?
0000
1100
1010
1001
?
1000
0100
0010
0001
?
1110
0000
00...

result:

ok correct! (10000 test cases)

Test #6:

score: 0
Accepted
time: 95ms
memory: 5832kb

input:

10000
4
0
1111
1111
1111
1111
0
0111
1111
1101
1111
0
1111
1111
1111
1111
0
0011
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
?
1000
0100
0010
0001
?
1110
0000
0000
0000
?
1100
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: 566ms
memory: 7740kb

input:

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

output:

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

result:

ok correct! (7368 test cases)

Test #8:

score: 0
Accepted
time: 564ms
memory: 7768kb

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: 441ms
memory: 7568kb

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: 494ms
memory: 7644kb

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: 498ms
memory: 7780kb

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
111111
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
100000
100000
100000
000010
100000
?
000000
00000...

result:

ok correct! (10000 test cases)

Test #12:

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

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: 355ms
memory: 7160kb

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: 366ms
memory: 7340kb

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: 418ms
memory: 7260kb

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: 316ms
memory: 7396kb

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
1000000
1000000
0000100
1000000
1000000
?
1111111
...

result:

ok correct! (10000 test cases)

Test #17:

score: 0
Accepted
time: 346ms
memory: 7436kb

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: 696ms
memory: 7696kb

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: 632ms
memory: 7760kb

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: 645ms
memory: 7732kb

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: 643ms
memory: 7676kb

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: 734ms
memory: 7808kb

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
0111111
0111111
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: 515ms
memory: 7760kb

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: 251ms
memory: 6744kb

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: 302ms
memory: 6792kb

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: 312ms
memory: 6708kb

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: 771ms
memory: 7760kb

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: 763ms
memory: 7744kb

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

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: 753ms
memory: 7704kb

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: 765ms
memory: 7732kb

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: 817ms
memory: 7796kb

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: 810ms
memory: 7676kb

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: 849ms
memory: 7732kb

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

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: 870ms
memory: 7680kb

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: 260ms
memory: 6768kb

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: 319ms
memory: 6792kb

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

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

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

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: 857ms
memory: 7760kb

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: 874ms
memory: 7760kb

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: 326ms
memory: 6716kb

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: 340ms
memory: 6808kb

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: 336ms
memory: 6764kb

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: 338ms
memory: 6732kb

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

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: 847ms
memory: 7800kb

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

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: 180ms
memory: 6788kb

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
1000000
1000000
1000000
0000100
1000000
1000000
?
1111111
...

result:

ok correct! (10000 test cases)

Test #52:

score: 0
Accepted
time: 254ms
memory: 6760kb

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

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
10000000
01000000
00100000
00010000
00001000
00000100
00000010
00000001
?
11111000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
11100000
00000000
00000000
00000000
00000000
00000000
00000000
00000000
?
11...

result:

ok correct! (10000 test cases)

Test #53:

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

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: 318ms
memory: 6744kb

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: 175ms
memory: 6772kb

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: 791ms
memory: 7764kb

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: 720ms
memory: 7760kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #58:

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

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: 516ms
memory: 7744kb

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: 699ms
memory: 7684kb

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
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
1000000
1000000
1000000
0000100
1000000
1000000
?
0000000
...

result:

ok correct! (10000 test cases)

Test #61:

score: 0
Accepted
time: 732ms
memory: 7680kb

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

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: 357ms
memory: 7804kb

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

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: 552ms
memory: 7444kb

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: 286ms
memory: 6828kb

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: 247ms
memory: 6784kb

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: 346ms
memory: 6852kb

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: 315ms
memory: 6840kb

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: 328ms
memory: 6820kb

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: 355ms
memory: 6800kb

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: 390ms
memory: 6840kb

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: 345ms
memory: 6796kb

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: 319ms
memory: 6860kb

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: 352ms
memory: 6816kb

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: 298ms
memory: 6800kb

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: 785ms
memory: 7804kb

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: 830ms
memory: 7744kb

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: 808ms
memory: 7764kb

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

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