QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#328224#7788. Rook DetectionCharlieVinnieAC ✓1063ms10444kbC++175.1kb2024-02-15 18:26:082024-02-15 18:26:09

Judging History

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

  • [2024-02-15 18:26:09]
  • 评测
  • 测评结果:AC
  • 用时:1063ms
  • 内存:10444kb
  • [2024-02-15 18:26:08]
  • 提交

answer

#include "bits/stdc++.h"
#ifdef DEBUG
#include "PrettyDebug.hpp"
#else
#define debug(...) [](auto...){}(__VA_ARGS__)
#define debuga(...) [](auto...){}(__VA_ARGS__)
#endif
#define For(i,a,b) for(int i=a;i<=b;i++)
#define Rev(i,a,b) for(int i=a;i>=b;i--)
#define Fin(file) freopen(file,"r",stdin)
#define Fout(file) freopen(file,"w",stdout)
using namespace std; typedef long long ll; using Map = vector<vector<int>>;
// #define IDEBUG
#ifdef IDEBUG
mt19937 rng(190345);
class Interactor{
    static constexpr int N=505;
    int n,a[N][N];
public:
    int start(){
        // #define MANUAL
        #ifdef MANUAL
        cin>>n; For(i,1,n) { string s; cin>>s; For(j,1,n) a[i][j]=s[j-1]-'0'; }; return n;
        #else
        n=5; For(i,1,n) For(j,1,n) a[i][j]=0;
        if(rng()&1) For(i,1,n) a[i][rng()%n+1]=1; 
        else For(i,1,n) a[rng()%n+1][i]=1;
        return n;
        #endif
    }
    Map query(Map mp){
        cout<<"Query:\n";
        For(i,1,n) { For(j,1,n) cout<<mp[i][j];; cout<<'\n'; }
        Map ans(n+1,vector<int>(n+1,0));
        For(i,1,n) For(j,1,n){
            For(k,1,n) if(mp[i][j]==mp[k][j]&&a[k][j]) ans[i][j]=1;
            For(k,1,n) if(mp[i][j]==mp[i][k]&&a[i][k]) ans[i][j]=1;
        }
        cout<<"Result:\n";
        For(i,1,n) { For(j,1,n) cout<<ans[i][j];; cout<<'\n'; }
        cout<<'\n';
        return ans;
    }
    void answer(Map ans){
        cout<<"Participant Answer:\n";
        For(i,1,n) { For(j,1,n) cout<<ans[i][j];; cout<<'\n'; }
        cout<<"Jury Answer:\n";
        For(i,1,n) { For(j,1,n) cout<<a[i][j];; cout<<'\n'; }
        int tt=0; For(i,1,n) For(j,1,n) if(ans[i][j]) { tt++; if(!a[i][j]) cout<<"Wrong Answer "<<i<<' '<<j<<'\n',exit(0); }
        if(tt<n) cout<<"Wrong Answer: Not enough rooks\n",exit(0);
        else cout<<"Accepted\n";
    }
};
#else
class Interactor{
    int n;
public:
    int start() { cin>>n; return n; }
    Map query(Map mp){
        cout<<"?\n"; For(i,1,n) { For(j,1,n) cout<<mp[i][j];; cout<<'\n'; }
        int result; cin>>result; if(result!=0) exit(0);
        Map res(n+1,vector<int>(n+1)); For(i,1,n) { string s; cin>>s; For(j,1,n) res[i][j]=s[j-1]-'0'; }
        return res;
    }
    void answer(Map ans){
        cout<<"!\n"; For(i,1,n) { For(j,1,n) cout<<ans[i][j];; cout<<'\n'; }
        int result; cin>>result; if(result!=0) exit(0);
    }
};
#endif
Interactor O; int n; Map ans;
void calc(vector<int> A,vector<int> B){
    vector<int> L(n+1),R(n+1),got(n+1); for(int o:A) L[o]=2,R[o]=n;
    while(true){
        int done=1; for(int o:A) if(L[o]==R[o]) ans[o][L[o]]=1; else { done=0; break; }
        if(done) break;
        vector<int> vis(n+1); Map mp(n+1,vector<int>(n+1));
        for(int o:A) if(L[o]!=R[o]){
            mp[o][1]=1; int mid=(L[o]+R[o])>>1; For(i,mid+1,R[o]) vis[i]=1,mp[o][i]=1;
        }
        for(int o:B) if(!vis[o]) got[o]=1,mp[o][o]=1;
        Map res=O.query(mp);
        for(int o:A) if(L[o]!=R[o]){
            int mid=(L[o]+R[o])>>1; if(res[o][1]) L[o]=mid+1; else R[o]=mid;
        }
        for(int o:B) if(!vis[o]) (res[o][o]?ans[o][o]:ans[o][1])=1;
    }
    vector<int> tmp; for(int o:B) if(!got[o]) tmp.push_back(o);
    if(tmp.size()){
        Map mp(n+1,vector<int>(n+1)); for(int o:tmp) mp[o][o]=1;
        Map res=O.query(mp); for(int o:tmp) (res[o][o]?ans[o][o]:ans[o][1])=1;
    }
    O.answer(ans);
}
void work(int qwq){
    debug(qwq);
    vector<int> L(n+1),R(n+1); For(o,1,n) L[o]=1,R[o]=n;
    while(true){
        int done=1; For(o,1,n) if(L[o]==R[o]) ans[L[o]][o]=1; else { done=0; break; }
        if(done) break;
        Map mp(n+1,vector<int>(n+1));
        For(o,1,n) if(L[o]!=R[o]){
            mp[qwq][o]=1; int mid=(L[o]+R[o])>>1; For(i,mid+1,R[o]) mp[i][o]=1;
        }
        Map res=O.query(mp);
        For(o,1,n) if(L[o]!=R[o]){
            int mid=(L[o]+R[o])>>1; if(res[qwq][o]) L[o]=mid+1; else R[o]=mid;
        }
    }
    O.answer(ans);
}
void solve(){
    n=O.start(); Map mp(n+1,vector<int>(n+1)); ans=mp;
    For(i,2,n) mp[i][1]=mp[i][i]=1;
    Map D=O.query(mp); mp=Map(n+1,vector<int>(n+1));
    if(!D[1][1]) return work(1),void();
    int zero=0; For(i,2,n) if(!D[i][i]) { zero=i; break; }
    if(!zero){
        For(i,1,n) mp[i][i]=1;
        Map S=O.query(mp);
        For(i,2,n) if(S[i][i]) ans[i][i]=1; else ans[i][1]=1;
        if(S[1][1]) ans[1][1]=1,O.answer(ans); else calc({1},{});
    }
    else{
        mp[1][1]=1; For(i,2,n) { mp[i][i]=1; if(D[i][i]) mp[i][1]=1; else if(i==zero) mp[1][i]=1; }
        Map S=O.query(mp); For(i,2,n) if(!S[i][1]) return work(i),void();
        vector<int> A,B; if(S[zero][zero]) ans[1][zero]=1; else if(S[1][zero]) ans[1][1]=1; else A.push_back(1);
        For(i,2,n) if(D[i][i]) B.push_back(i); else A.push_back(i);
        calc(A,B);
    }
}
signed main(){
    atexit([](){cerr<<"Time = "<<clock()<<" ms"<<endl;});
    int T; cin>>T; while(T--) solve();
    return 0;
}

// CONTINUE, NON-STOPPING, FOR CHARLIEY
// START TYPING IF YOU DON'T KNOW WHAT TO DO
// STOP TYPING IF YOU DON'T KNOW WHAT YOU'RE DOING

// Started Coding On: February 15 Thu, 16 : 32 : 01

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

Details

Tip: Click on the bar to expand more detailed information

Test #1:

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

input:

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

output:

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

result:

ok correct! (1 test case)

Test #2:

score: 0
Accepted
time: 74ms
memory: 3680kb

input:

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

output:

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

result:

ok correct! (9898 test cases)

Test #3:

score: 0
Accepted
time: 97ms
memory: 3560kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #4:

score: 0
Accepted
time: 101ms
memory: 3740kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #5:

score: 0
Accepted
time: 92ms
memory: 3876kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #6:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #7:

score: 0
Accepted
time: 729ms
memory: 10444kb

input:

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

output:

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

result:

ok correct! (7368 test cases)

Test #8:

score: 0
Accepted
time: 666ms
memory: 10068kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #9:

score: 0
Accepted
time: 604ms
memory: 9340kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #10:

score: 0
Accepted
time: 619ms
memory: 9664kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #11:

score: 0
Accepted
time: 679ms
memory: 10412kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #12:

score: 0
Accepted
time: 310ms
memory: 8824kb

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: 497ms
memory: 8940kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #14:

score: 0
Accepted
time: 429ms
memory: 7676kb

input:

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

output:

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

input:

10000
9
0
111111111
111111111
111111111
111111111
111111111
111110111
111111011
111111111
111111110
0
111111111
111111111
111111111
111111111
111111111
111110111
011111011
111111111
011111110
0
111111111
111111111
111111111
111111111
111111111
111111111
110111011
111111111
110111011
0
111111111
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #16:

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

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
0111011
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
?
1100000
0100000
1010000
1001000
0000100
1000010
1000001
?
0000000
...

result:

ok correct! (10000 test cases)

Test #17:

score: 0
Accepted
time: 515ms
memory: 8556kb

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
01011111
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: 894ms
memory: 10316kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #19:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #20:

score: 0
Accepted
time: 867ms
memory: 10348kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #21:

score: 0
Accepted
time: 793ms
memory: 10292kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #22:

score: 0
Accepted
time: 801ms
memory: 10444kb

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
0011111
1011111
1111111
1111111
1111011
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #23:

score: 0
Accepted
time: 623ms
memory: 10272kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #24:

score: 0
Accepted
time: 331ms
memory: 5484kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #25:

score: 0
Accepted
time: 393ms
memory: 5560kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #26:

score: 0
Accepted
time: 441ms
memory: 5424kb

input:

10000
7
0
1111111
1111111
1101111
1110111
1111011
1111101
1011111
0
1101111
1111111
1101111
1110111
1111011
1111101
1011111
0
1011111
1111000
1011111
0111111
0111111
1011111
1111111
0
0111111
1110110
0111111
0111111
1011110
1010111
1111111
0
0111111
1101101
1001111
1011101
1111111
1111111
1111110
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #27:

score: 0
Accepted
time: 961ms
memory: 10260kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #28:

score: 0
Accepted
time: 942ms
memory: 10248kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #29:

score: 0
Accepted
time: 964ms
memory: 10248kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #30:

score: 0
Accepted
time: 954ms
memory: 10332kb

input:

10000
8
0
11111111
10111111
11101101
11011101
11110111
11001101
11001111
11111110
0
10111111
10111111
11101101
11011101
11110111
11001101
11001111
11111110
0
11001111
01111101
11101010
11011010
01111101
11111111
11111111
11001111
0
11010101
11011100
11110100
11111111
01101111
11111011
11010110
01111...

output:

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

result:

ok correct! (10000 test cases)

Test #31:

score: 0
Accepted
time: 886ms
memory: 10252kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #32:

score: 0
Accepted
time: 973ms
memory: 10328kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #33:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #34:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #35:

score: 0
Accepted
time: 1031ms
memory: 10320kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #36:

score: 0
Accepted
time: 1037ms
memory: 10248kb

input:

10000
9
0
111111111
111111011
110111111
111011111
111101111
111110111
111111111
111111101
111111110
0
110111111
111111011
110111111
111011111
111101111
111110111
111111111
111111101
111111110
0
011111011
101111111
111111111
111111111
011111011
111111111
111111111
011111011
011111011
0
111111000
1011...

output:

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

result:

ok correct! (10000 test cases)

Test #37:

score: 0
Accepted
time: 475ms
memory: 5620kb

input:

10000
7
0
1111111
1011111
1111111
1110111
1111011
1111101
1111110
0
1011111
0011111
1111111
1110111
1111011
1111101
1111110
0
1111111
0111010
1111111
1111111
1111111
1111111
1111111
0
1111111
1010011
1111111
1111111
1111111
1111111
0111110
0
1111111
0110011
1111111
1111111
1111111
1111111
1111111
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #38:

score: 0
Accepted
time: 490ms
memory: 5428kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #39:

score: 0
Accepted
time: 475ms
memory: 5176kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #40:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #41:

score: 0
Accepted
time: 967ms
memory: 10320kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #42:

score: 0
Accepted
time: 942ms
memory: 10312kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #43:

score: 0
Accepted
time: 970ms
memory: 10444kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #44:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #45:

score: 0
Accepted
time: 455ms
memory: 5032kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #46:

score: 0
Accepted
time: 415ms
memory: 5416kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #47:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #48:

score: 0
Accepted
time: 929ms
memory: 10392kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #49:

score: 0
Accepted
time: 926ms
memory: 10340kb

input:

10000
9
0
111111111
111111111
111111111
111111111
111101111
111110111
111111011
111111111
111111111
0
111101111
111111111
111111111
111111111
111101111
111110111
111111011
111111111
111111111
0
111111111
111111111
111111111
111011111
011111100
011111100
111111111
111111111
111111111
0
011111100
1111...

output:

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

result:

ok correct! (10000 test cases)

Test #50:

score: 0
Accepted
time: 977ms
memory: 10328kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #51:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #52:

score: 0
Accepted
time: 332ms
memory: 5028kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #53:

score: 0
Accepted
time: 313ms
memory: 5316kb

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: 430ms
memory: 5096kb

input:

10000
8
0
11111111
10111111
11111111
11101111
11111111
11111111
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
?
11000000
01000000
10100000
00010000
10001000
10000100
10000010
10000001
?
00000000
10000111
00100000
10000111
00001000
00000000
00000000
00000000
?
00000000
10000001
00100000
10000001
00001000
00000100
00000010
00000000
?
00...

result:

ok correct! (10000 test cases)

Test #55:

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

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: 941ms
memory: 10320kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #57:

score: 0
Accepted
time: 862ms
memory: 10392kb

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: 638ms
memory: 10288kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #59:

score: 0
Accepted
time: 673ms
memory: 10404kb

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: 845ms
memory: 10300kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #61:

score: 0
Accepted
time: 879ms
memory: 10332kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #62:

score: 0
Accepted
time: 806ms
memory: 10328kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #63:

score: 0
Accepted
time: 513ms
memory: 8328kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #64:

score: 0
Accepted
time: 461ms
memory: 8272kb

input:

10000
9
0
111111111
101111111
111111111
111011111
111101111
111110111
111111111
111111111
111111110
0
111111111
101111111
111111111
111011111
111101111
111110111
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
?
110000000
010000000
101000000
000100000
000010000
000001000
100000100
100000010
000000001
?
000000000
100001111
001000000
100001111
100001111
100001111
000000000
000000000
100001111
?
000000000
100000011
00...

result:

ok correct! (10000 test cases)

Test #65:

score: 0
Accepted
time: 608ms
memory: 8308kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #66:

score: 0
Accepted
time: 403ms
memory: 5168kb

input:

10000
7
0
1111111
1110010
1101111
1111010
1111011
1111101
1110011
0
1110010
1110010
1101111
1111010
1111011
1111101
1110011
0
1111111
1011111
1110111
1111000
0111010
0111010
1111111
0
1111111
1011111
0111110
1111111
0110111
0110111
1111111
0
1111111
1011111
1100010
1101000
1110000
0111111
1111110
0
...

output:

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

result:

ok correct! (10000 test cases)

Test #67:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #68:

score: 0
Accepted
time: 432ms
memory: 5364kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #69:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #70:

score: 0
Accepted
time: 443ms
memory: 5420kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #71:

score: 0
Accepted
time: 426ms
memory: 5380kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #72:

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

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #73:

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

input:

10000
8
0
01011111
10011111
11111111
11001111
11110111
11011111
11011101
11011110
0
10010001
01111110
11111111
01111110
11111111
11111111
10010001
10010001
0
01101110
10010001
11111111
11111111
11111111
11111111
00000000
00000000
0
10000000
01111111
11111111
00010001
11111111
11111111
01111111
01111...

output:

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

result:

ok correct! (10000 test cases)

Test #74:

score: 0
Accepted
time: 457ms
memory: 5424kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #75:

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

input:

10000
8
0
11111111
10111101
11111101
11101101
11110101
11111001
11111111
11111100
0
10111111
00111101
11111101
01101101
01110101
01111001
11111111
01111100
0
11111111
01110011
11111111
10001100
01110011
01110011
11111111
01110011
0
11111111
11110011
10001100
10000000
00001100
00001100
01111111
01111...

output:

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

result:

ok correct! (10000 test cases)

Test #76:

score: 0
Accepted
time: 415ms
memory: 5104kb

input:

10000
8
0
11111111
00111111
01011111
11111111
01110111
01111011
11111111
11111111
0
11111111
00111111
01011111
11111111
11110111
01111011
11111111
11111111
0
11111111
01011111
10111001
11111111
11111111
01011111
11111111
11111111
0
11111111
01011111
01011111
01011111
11111111
11111111
11111111
11111...

output:

?
00000000
11000000
10100000
10010000
10001000
10000100
10000010
10000001
?
11000000
01000000
00100000
10010000
00001000
00000100
10000010
10000001
?
00000000
11111111
00000000
00000000
11111111
11111111
11111111
11111111
?
00000000
11111111
10100000
10100000
00000000
00000000
01011111
01011111
?
00...

result:

ok correct! (10000 test cases)

Test #77:

score: 0
Accepted
time: 1063ms
memory: 10308kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #78:

score: 0
Accepted
time: 1006ms
memory: 10336kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #79:

score: 0
Accepted
time: 992ms
memory: 10268kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Test #80:

score: 0
Accepted
time: 906ms
memory: 10320kb

input:

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

output:

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

result:

ok correct! (10000 test cases)

Extra Test:

score: 0
Extra Test Passed