#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];
int Q;
#endif

int 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);
  int s;
#ifdef LOCAL
  ++Q;
  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
  return s;
}

int A[N][N];
void Answer() {
#ifdef LOCAL
  for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
    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
}


map<vector<int>, vector<int>> psss[6];
void small() {
  for (int n = 3; n <= 5; ++n) {
    const int m = n * (n - 1) / 2;
    for (int p = 0; p < 1 << m; ++p) {
      int a[5][5] = {};
      {
        int pos = 0;
        for (int u = 0; u < n; ++u) for (int v = u + 1; v < n; ++v) {
          a[u][v] = a[v][u] = p >> pos & 1;
          ++pos;
        }
      }
      vector<int> fs;
      for (int u = 0; u < n; ++u) for (int v = u + 1; v < n; ++v) for (int w = v + 1; w < n; ++w) {
        fs.push_back(a[u][v] + a[v][w] + a[w][u]);
      }
      psss[n][fs].push_back(p);
    }
#ifdef LOCAL
    for (const auto &kv : psss[n]) if (kv.second.size() >= 2) {
      cerr << kv.first;
      for (const int p : kv.second) {
        cerr << " ";
        for (int i = 0; i < m; ++i) cerr << ((p >> i) & 1);
      }
      cerr << endl;
    }
#endif
  }
}

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

void determine(int n, int us[]) {
  assert(3 <= n); assert(n <= 5);
  vector<int> fs;
  for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) for (int k = j + 1; k < n; ++k) {
    fs.push_back(Ask(us[i], us[j], us[k]));
  }
  auto it = psss[n].find(fs);
  assert(it != psss[n].end());
  {
    int pos = 0;
    for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) {
      bool ok = true;
      int c = -1;
      for (const int p : it->second) {
        if (!~c) c = p >> pos & 1;
        ok = ok && (c == (p >> pos & 1));
      }
      if (ok) {
        ae(us[i], us[j], c);
      }
      ++pos;
    }
  }
}

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
  
  small();
  
  for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) if (u != v) {
    A[u][v] = -1;
  }
  
  vector<int> qs;
  {
    int us[4];
    for (us[0] = 0        ; us[0] < N; ++us[0])
    for (us[1] = us[0] + 1; us[1] < N; ++us[1])
    for (us[2] = us[1] + 1; us[2] < N; ++us[2])
    for (us[3] = us[2] + 1; us[3] < N; ++us[3])
    {
      bool ok = true;
      for (int i = 0; i < 4; ++i) for (int j = i + 1; j < 4; ++j) {
        ok = ok && (!~A[us[i]][us[j]]);
      }
      if (ok) {
        int key = 0;
        for (int i = 0; i < 4; ++i) key |= us[i] << (8*i);
        qs.emplace_back(key);
      }
    }
  }
// cerr<<"|qs| = "<<qs.size()<<endl;
  for (int i = 0; i < (int)qs.size(); ++i) {
    swap(qs[xrand(0, i)], qs[i]);
  }
  for (const int key : qs) {
    int us[4];
    for (int i = 0; i < 4; ++i) us[i] = key >> (8*i) & 255;
    bool ok = true;
    for (int i = 0; i < 4; ++i) for (int j = i + 1; j < 4; ++j) {
      ok = ok && (!~A[us[i]][us[j]]);
    }
    if (ok) {
      determine(4, us);
    }
  }
  
  int mn = N;
  int rm = -1;
  for (int r = 0; r < N; ++r) {
    int cnt = 0;
    for (int u = 0; u < N; ++u) if (r != u && !~A[r][u]) {
      ++cnt;
    }
    if (chmin(mn, cnt)) {
      rm = r;
    }
  }
// cerr<<"mn = "<<mn<<endl;
  {
    vector<int> ss;
    for (int u = 0; u < N; ++u) if (rm != u && !~A[rm][u]) {
      ss.push_back(u);
    }
    const int ssLen = ss.size();
    for (int h = 0; h < ssLen; h += 4) {
      vector<int> used(N, 0);
      int us[5];
      fill(us, us + 5, -1);
      used[us[0] = rm] = 1;
      for (int i = 1; i < 5; ++i) if (h + (i - 1) < ssLen) {
        used[us[i] = ss[h + (i - 1)]] = 1;
      }
      for (int i = 1; i < 5; ++i) if (!~us[i]) {
        for (int u = 0; u < N; ++u) if (!used[u]) {
          used[us[i] = u] = 1;
          break;
        }
        assert(~us[i]);
      }
// pv(us,us+5);
      determine(5, us);
    }
  }
  for (int u = 0; u < N; ++u) for (int v = u + 1; v < N; ++v) if (!~A[u][v]) {
    const int res = Ask(rm, u, v);
    ae(u, v, res - A[rm][u] - A[rm][v]);
  }
  
  Answer();
  return 0;
}