#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


// [0, 2^32)
unsigned xrand() {
  static unsigned x = 314159265, y = 358979323, z = 846264338, w = 327950288;
  unsigned t = x ^ x << 11; x = y; y = z; z = w; return w = w ^ w >> 19 ^ t ^ t >> 8;
}

// [a, b]
int xrand(int a, int b) { return a + xrand() % (b - a + 1); }


constexpr int N = 100;

#ifdef LOCAL
int secret[N][N];
#endif

int Q;
int F[N][N][N];
void Ask(int u, int v, int w) {
  assert(0 <= u); assert(u < N);
  assert(0 <= v); assert(v < N);
  assert(0 <= w); assert(w < N);
  assert(u != v); assert(v != w); assert(w != u);
  if (!~F[u][v][w]) {
    ++Q;
    int s;
#ifdef LOCAL
    s = secret[u][v] + secret[v][w] + secret[w][u];
#else
    printf("? %d %d %d\n", u + 1, v + 1, w + 1);
    fflush(stdout);
    scanf("%d", &s);
#endif
    F[u][v][w] = s;
    F[u][w][v] = s;
    F[v][w][u] = s;
    F[v][u][w] = s;
    F[w][u][v] = s;
    F[w][v][u] = s;
  }
}

int A[N][N];
void Answer() {
#ifdef LOCAL
  for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
    if (secret[u][v] != A[u][v]) {
      cerr << "Wrong Answer " << u << " " << v << ": " << secret[u][v] << " " << A[u][v] << endl;
    }
    assert(secret[u][v] == A[u][v]);
  }
  cerr << "Accepted: Q = " << Q << endl;
#else
  puts("!");
  for (int u = 0; u < N; ++u) {
    for (int v = 0; v < N; ++v) {
      printf("%d", A[u][v]);
    }
    puts("");
  }
  fflush(stdout);
#endif
}


bool ae(int u, int v, int c) {
  assert(0 <= u); assert(u < N);
  assert(0 <= v); assert(v < N);
  assert(c == 0 || c == 1);
  bool upd = false;
  if (!~A[u][v]) {
    upd = true;
    A[u][v] = A[v][u] = c;
  }
  assert(A[u][v] == c);
  assert(A[v][u] == c);
  return upd;
}

bool update(int n, const int *us) {
  static constexpr int limN = 5;
  assert(n <= limN);
  bool can[limN][limN][2] = {};
  for (int p = 0; p < 1 << (n*(n-1)/2); ++p) {
    int a[limN][limN] = {};
    {
      int pos = 0;
      for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) {
        a[i][j] = a[j][i] = p >> pos & 1;
        ++pos;
      }
    }
    bool ok = true;
    for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) if (~A[us[i]][us[j]]) {
      ok = ok && (A[us[i]][us[j]] == a[i][j]);
    }
    for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) for (int k = j + 1; k < n; ++k) if (~F[us[i]][us[j]][us[k]]) {
      ok = ok && (F[us[i]][us[j]][us[k]] == a[i][j] + a[j][k] + a[k][i]);
    }
    if (ok) {
      for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) {
        can[i][j][a[i][j]] = true;
      }
    }
  }
  bool upd = false;
  for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) {
    for (int c = 0; c < 2; ++c) if (!can[i][j][c ^ 1]) {
      if (ae(us[i], us[j], c)) {
        upd = true;
      }
    }
  }
  return upd;
}

void update3s() {
  for (; ; ) {
    bool upd = false;
    for (int u = 0; u < N; ++u) for (int v = u + 1; v < N; ++v) for (int w = v + 1; w < N; ++w) {
      const int us[3] = {u, v, w};
      if (update(3, us)) {
        upd = true;
      }
    }
    if (!upd) break;
  }
}

int R;
vector<int> U;

int counter;
void rec(int l, int r) {
  if (r - l >= 3) {
    const int mid = l + (r - l + 0) / 2;
    for (int x = 0; x < mid - l; ++x) for (int y = x + 1; y < mid - l; ++y) {
++counter;
      constexpr int n = 4;
      const int us[n] = {
        R,
        U[l + x],
        U[l + y],
        U[mid + (x + y) % (r - mid)],
      };
      auto check = [&]() -> bool {
        update(n, us);
        for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) {
          if (!~A[us[i]][us[j]]) {
            return false;
          }
        }
        return true;
      };
      if (!~A[us[1]][us[2]] && !~A[us[2]][us[3]] && !~A[us[3]][us[1]]) {
        Ask(us[1], us[2], us[3]); if (check()) continue;
        Ask(us[0], us[2], us[3]); if (check()) continue;
        Ask(us[0], us[1], us[3]); if (check()) continue;
        assert(false);
      }
      if (~A[us[1]][us[2]] && !~A[us[2]][us[3]] && !~A[us[3]][us[1]]) {
        Ask(us[1], us[2], us[3]); if (check()) continue;
        Ask(us[0], us[2], us[3]); if (check()) continue;
        assert(false);
      }
      if (!~A[us[1]][us[2]] && ~A[us[2]][us[3]] && !~A[us[3]][us[1]]) {
        Ask(us[1], us[2], us[3]); if (check()) continue;
        Ask(us[0], us[1], us[3]); if (check()) continue;
        assert(false);
      }
      if (!~A[us[1]][us[2]] && !~A[us[2]][us[3]] && ~A[us[3]][us[1]]) {
        Ask(us[1], us[2], us[3]); if (check()) continue;
        Ask(us[0], us[2], us[3]); if (check()) continue;
        assert(false);
      }
    }
    rec(mid, r);
  }
}

int main() {
#ifdef LOCAL
  for (int u = 0; u < N; ++u) {
    char buf[N + 1];
    scanf("%s", buf);
    for (int v = 0; v < N; ++v) {
      secret[u][v] = buf[v] - '0';
    }
  }
  for (int u = 0; u < N; ++u) {
    assert(secret[u][u] == 0);
  }
  for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
    assert(secret[u][v] == secret[v][u]);
  }
#endif
  
  memset(A, ~0, sizeof(A));
  for (int u = 0; u < N; ++u) A[u][u] = 0;
  memset(F, ~0, sizeof(F));
  
  R = xrand() % N;
  for (int u = 0; u < N; ++u) if (R != u) U.push_back(u);
  for (int i = 0; i < N - 1; ++i) swap(U[xrand(0, i)], U[i]);
cerr<<"R = "<<R<<", U = "<<U<<endl;
  
  // connect (R, *)
  for (int h = 0; h < N - 1; ) {
    int us[5];
    us[0] = R;
    for (int i = 1; i < 5; ++i) {
      us[i] = U[(h + (i - 1)) % (N - 1)];
    }
cerr<<"us = ";pv(us,us+5);
    for (int n = 3; ; ++n) {
      for (int i = 0; i < n - 1; ++i) for (int j = i + 1; j < n - 1; ++j) {
        Ask(us[i], us[j], us[n - 1]);
        update(n, us);
        bool done = true;
        for (int k = 1; k < n; ++k) {
          done = done && (~A[R][us[k]]);
        }
        if (done) {
          h += (n - 1);
          goto found;
        }
      }
      if (n == 5) {
        assert(false);
      }
    }
   found:{}
  }
  for (const int u : U) {
    assert(~A[R][u]);
  }
cerr<<"Q = "<<Q<<endl;
  update3s();
cerr<<"Q = "<<Q<<endl;
  
  rec(0, N - 1);
cerr<<"Q = "<<Q<<endl;
  update3s();
cerr<<"Q = "<<Q<<endl;
  
  for (int u = 0; u < N; ++u) for (int v = u + 1; v < N; ++v) if (!~A[u][v]) {
    Ask(R, u, v);
    ae(u, v, F[R][u][v] - A[R][u] - A[R][v]);
  }
  
  Answer();
  return 0;
}