#pragma GCC optimize("Ofast,unroll-loops")

#include<bits/stdc++.h>
using namespace std;

#define rep(i,a,b) for(int i=(a),i##end=(b);i<=i##end;++i)
#define per(i,a,b) for(int i=(a),i##end=(b);i>=i##end;--i)
//mt19937 Rnd(19260817);
mt19937 Rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
template<typename T>void chkmax(T&x,const T&y){if(x<y)x=y;}
template<typename T>void chkmin(T&x,const T&y){if(y<x)x=y;}

#define pb push_back
#define ALL(x) (x).begin(),(x).end()
#define mem(x) memset((x),0,sizeof(x))

typedef double db;
typedef long long ll;
typedef vector<int>vi;
typedef pair<int,int>pii;

typedef unsigned u32;
typedef unsigned uint;
typedef unsigned long long u64;

const int n=100;

#ifdef Arraiter
const bool Irisu=1;
#else
const bool Irisu=0;
#endif
bool mp[105][105];int sf[105],fs[105];int use_q=0;

bool ans[105][105];

struct Querys{
  int a,b,c,v;
};
vector<Querys>Q;

int ask(int a,int b,int c){
  int v;
  a=sf[a],b=sf[b],c=sf[c];
  if(Irisu){
    use_q++;
    v=mp[a][b]+mp[b][c]+mp[a][c];
    Q.pb({fs[a],fs[b],fs[c],v});
    return v;
  }
  printf("? %d %d %d\n",a,b,c);
  fflush(stdout);
  scanf("%d",&v);
  Q.pb({fs[a],fs[b],fs[c],v});
  return v;
}

void answer(){
  if(Irisu){
    bool asf=1;
    rep(i,1,n)rep(j,1,n)asf&=ans[fs[i]][fs[j]]==mp[i][j];
    if(asf){
      puts("AC");
      printf("count : %d\n",use_q);
    }else{
      puts("WA");
    }
    return;
  }
  puts("!");
  rep(i,1,n){
    rep(j,1,n)putchar(ans[fs[i]][fs[j]]|48);
    puts("");
  }
}

const int maxn=5000;
const int m=4950;

int tid[105][105];pii dit[maxn];

struct bit{
  u64 seq[78];
  void reset(){
    mem(seq);
  }
  void set(int pos){
    seq[pos>>6]|=1ull<<(pos&63);
  }
  void flip(int pos){
    seq[pos>>6]^=1ull<<(pos&63);
  }
  bool operator[](int pos)const{
    return seq[pos>>6]>>(pos&63)&1;
  }
  void operator^=(const bit&o){
    rep(i,0,77)seq[i]^=o.seq[i];
  }
  void doit_pre(const bit&o,int pos){
    rep(i,0,pos>>6)seq[i]^=o.seq[i];
  }
  void doit_suf(const bit&o,int pos){
    rep(i,pos>>6,77)seq[i]^=o.seq[i];
  }
};

//typedef bitset<maxn>bit;
int rk;
bit B[maxn];bool bb[maxn];
bool ins(bit&x){
  per(i,m,1)if(x[i]){
    if(bb[i]){
//      x^=B[i];
      x.doit_pre(B[i],i);
      continue;
    }
    rk++;
    bb[i]=1;
    B[i]=x;
    return 1;
  }
  return 0;
}

void solve(){
  rep(i,1,n)sf[i]=i;
  shuffle(sf+1,sf+n+1,Rnd);
  rep(i,1,n)fs[sf[i]]=i;
  if(Irisu){
    rep(i,1,n)rep(j,i+1,n)mp[i][j]=mp[j][i]=i<50&&j>=50;
//    rep(i,1,n)rep(j,i+1,n)mp[i][j]=mp[j][i]=Rnd()%100<0;
  }
  
  {
    int c=0;
    rep(i,1,n)rep(j,1,i-1)tid[i][j]=tid[j][i]=++c,dit[c]={i,j};
  }
  
  static int buk[maxn];
  memset(buk,-1,sizeof buk);
  
  bit w;
  auto upd=[&](int i,int v){
    if(buk[i]==-1){
      buk[i]=v;
      w.reset(),w.set(i),ins(w);
    }
  };
  int eq=-1;
  rep(s,3,n){
    vector<pii>lef;
    rep(a,1,s-1)rep(b,a+1,s-1){
      lef.pb({a,b});
    }
    shuffle(ALL(lef),Rnd);
    for(auto[a,b]:lef){
      w.reset();
      w.set(tid[a][b]),w.set(tid[a][s]),w.set(tid[b][s]);
      if(!ins(w))continue;
      int v=ask(a,b,s);
      if(eq==-1)eq=v;
      else if(eq!=v)eq=-2;
      if(v==0||v==3){
        upd(tid[a][b],v>0);
        upd(tid[a][s],v>0);
        upd(tid[s][b],v>0);
      }else{
        
      }
      if(rk==s*(s-1)/2){
//        printf("#%d\n",s);
        break;
      }
    }
    if(s==n||(s>20&&rk==s*(s-1)/2)||((s>20)&&(eq==-2||eq==1||eq==2))){
      static bit a[20000];
      int tot=0;
      int L=s*(s-1)/2;
      for(auto[x,y,z,v]:Q){
        int i=tid[x][y],j=tid[x][z],k=tid[y][z];
        if(v>0&&v<3){
          if(v==1){
            if(buk[i]==1||buk[j]==1||buk[k]==1){
              if(buk[i]==-1)buk[i]=0;
              if(buk[j]==-1)buk[j]=0;
              if(buk[k]==-1)buk[k]=0;
            }
          }
          if(v==2){
            if(buk[i]==0||buk[j]==0||buk[k]==0){
              if(buk[i]==-1)buk[i]=1;
              if(buk[j]==-1)buk[j]=1;
              if(buk[k]==-1)buk[k]=1;
            }
          }
          if(buk[i]!=-1&&buk[j]!=-1&&buk[k]!=-1)continue;
          tot++;
          a[tot].set(i);
          a[tot].set(j);
          a[tot].set(k);
          if(v&1)a[tot].set(L+1);
        }
      }
      rep(i,1,L)if(buk[i]!=-1){
        tot++;
        a[tot].set(i);
        if(buk[i])a[tot].set(L+1);
      }
      rep(i,1,L){
        if(!a[i][i]){
          rep(j,i+1,tot)if(a[j][i]){
            swap(a[i],a[j]);break;
          }
        }
        rep(j,i+1,tot)if(a[j][i]){
          a[j].doit_suf(a[i],i);
    //      a[j]^=a[i];
        }
      }
      per(i,L,1){
        assert(a[i][i]);
        buk[i]=a[i][L+1];
        if(a[i][L+1]){
          rep(j,1,i-1)if(a[j][i]){
            a[j].flip(L+1);
          }
        }
      }
      
    //  printf("!%d, %d\n",rk,use_q);
      
      rep(t,s+1,n){
        vector<pii>o;
        int lst=-1;
        rep(i,1,t-1){
          if(lst==-1){
            lst=i;continue;
          }
          int v=ask(lst,i,t);
          if(v==0||v==3){
            buk[tid[lst][i]]=buk[tid[i][t]]=buk[tid[lst][t]]=v>0;
            lst=-1;
          }else if(v%2==buk[tid[lst][i]]){
            buk[tid[i][t]]=buk[tid[lst][t]]=!(v%2);
            lst=-1;
          }else{
            o.pb({lst,i});
            lst=i;
          }
        }
        reverse(ALL(o));
        for(auto[a,b]:o)if(buk[tid[b][t]]!=-1)buk[tid[a][t]]=!buk[tid[b][t]];
        rep(lst,1,t-1)if(buk[tid[lst][t]]==-1){
          rep(i,1,t-1)if(i!=lst){
            bool can=1;
            for(auto[a,b]:o){
              if(lst==a)can&=i!=b;
              if(lst==b)can&=i!=a;
            }
            if(!can)continue;
            assert(buk[tid[i][t]]!=-1);
            int v=ask(lst,i,t);
            buk[tid[lst][t]]=v-buk[tid[lst][i]]-buk[tid[i][t]];
            lst=-1;
            break;
          }
          if(lst==-1)break;
        }
        rep(_,0,o.size()){
          for(auto[a,b]:o)if(buk[tid[b][t]]!=-1)buk[tid[a][t]]=!buk[tid[b][t]];
          for(auto[a,b]:o)if(buk[tid[a][t]]!=-1)buk[tid[b][t]]=!buk[tid[a][t]];
        }
      }
      break;
    }
  }
  
  rep(i,1,n)rep(j,i+1,n)ans[i][j]=ans[j][i]=buk[tid[i][j]];
  
  answer();
}

signed main(){
//  int T;cin>>T;while(T--)solve();
  solve();
  return 0;
}