// #define DEBUG
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
using namespace std;

using vi = vector<int>;

int A[509][509];

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

constexpr int N = 5e2 + 9;
int n, c1[N][N], c2[N][N];

#ifdef DEBUG
void start () {
  n = rng() % 3 + 4;
  L (i, 1, n) {
    L (j, 1, n) {
      A[i][j] = 0;
    }
  }
  if (rng() % 2) {
    L (i, 1, n) {
      A[i][rng() % n + 1] = 1;
    }
  } else {
    L (i, 1, n) {
      A[rng() % n + 1][i] = 1;
    }
  }
}
#endif

int C[N][N];
IL void ask () {
  #ifdef DEBUG 
  static int c[N][N];
  L (i, 1, n) {
    L (j, 1, n) {
      c[i][j] = 0;
    }
  }
  L (i, 1, n) {
    L (j, 1, n) {
      if (A[i][j]) {
        L (k, 1, n) {
          c[i][k] |= (C[i][j] == C[i][k]);
          c[k][j] |= (C[i][j] == C[k][j]);
        }
      }
    }
  }
  L (i, 1, n) {
    L (j, 1, n) {
      C[i][j] = c[i][j];
    }
  }
  #else 
  cout << "?\n";
  L (i, 1, n) {
    L (j, 1, n) {
      cout << C[i][j];
    }
    cout << '\n';
  }
  cout.flush();
  int g;
  cin >> g;
  assert(g == 0);
  L (i, 1, n) {
    static string s;
    cin >> s;
    L (j, 1, n) {
      C[i][j] = s[j - 1] ^ 48;
    }
  }
  #endif
}

int a[N][N];

#ifdef DEBUG 
void err () {
  cout << n << '\n';
  L (i, 1, n) {
    L (j, 1, n) {
      cout << A[i][j];
    }
    cout << '\n';
  }
  L (i, 1, n) {
    L (j, 1, n) {
      cout << a[i][j];
    }
    cout << '\n';
  }
  exit(-1);
}
#endif

IL void rep () {
  #ifdef DEBUG 
  int x = 0;
  L (i, 1, n) {
    L (j, 1, n) {
      if (a[i][j]) {
        if (!A[i][j]) {
          err();
        } else {
          ++x;
        }
      }
    }
  }
  if (x < n) {
    err();
  }
  #else
  cout << "!\n";
  L (i, 1, n) {
    L (j, 1, n) {
      cout << a[i][j];
    }
    cout << '\n';
  }
  cout.flush();
  int g;
  cin >> g;
  assert(g == 0);
  #endif
}

IL void clr () {
  L (i, 1, n) {
    L (j, 1, n) {
      C[i][j] = 0;
    }
  }
}

int L[N], R[N];

namespace BF1 {
  void main (int X) {
    cerr << 1 << '\n';
    L (i, 1, n) {
      L[i] = 1, R[i] = n;
    }
    while (1) {
      clr();
      L (i, 1, n) {
        if (L[i] < R[i]) {
          int m = (L[i] + R[i]) >> 1;
          L (j, L[i], m) {
            C[j][i] = 1;
          }
        }
      }
      L (i, 1, n) {
        C[X][i] = 1;
      }
      ask();
      bool ok = 0;
      L (i, 1, n) {
        if (L[i] < R[i]) {
          int m = (L[i] + R[i]) >> 1;
          C[X][i] ? R[i] = m : L[i] = m + 1;
          ok |= L[i] < R[i];
        }
      }
      if (!ok) {
        break;
      }
    }
    L (i, 1, n) {
      a[L[i]][i] = 1;
    }
    rep();
  }
}

namespace BF2 {
  void main () {
    cerr << 2 << '\n';
    clr();
    L (i, 1, n) {
      C[i][i] = 1;
    }
    ask();
    L (i, 2, n) {
      a[i][C[i][i] ? i : 1] = 1;
    }
    if (C[1][1]) {
      a[1][1] = 1;
      rep();
      return;
    }
    int l = 2, r = n;
    while (l < r) {
      int m = (l + r) >> 1;
      clr();
      C[1][1] = 1;
      L (i, l, m) {
        C[1][i] = 1;
      }
      ask();
      C[1][1] ? r = m : l = m + 1;
    }
    a[1][l] = 1;
    rep();
    return;
  }
}

namespace BF3 {
  bool vis[N], ban[N], need[N];

  void clr () {
    L (i, 1, n) {
      vis[i] = need[i] = 0;
    }
  }

  void main () {
    cerr << 3 << '\n';
    L (i, 1, n) {
      if (need[i]) {
        L[i] = 1, R[i] = n;
      } else {
        L[i] = R[i] = 0;
      }
    }
    while (1) {
      ::clr();
      L (i, 1, n) {
        ban[i] = 0;
      }
      L (i, 1, n) {
        if (L[i] < R[i]) {
          int m = (L[i] + R[i]) >> 1;
          L (j, L[i], m) {
            C[i][j] = 1;
            ban[j] = 1;
          }
          C[i][1] = 1;
        }
      }
      L (i, 1, n) {
        if (!need[i] && !vis[i] && !ban[i]) {
          C[i][i] = 1;
        }
      }
      ask();
      bool fl = 0;
      L (i, 1, n) {
        if (!need[i] && !vis[i]) {
          if (!ban[i]) {
            a[i][C[i][i] ? i : 1] = 1;
            vis[i] = 1;
          } else {
            fl = 1;
          }
        }
      }
      L (i, 1, n) {
        if (L[i] < R[i]) {
          int m = (L[i] + R[i]) >> 1;
          C[i][1] ? R[i] = m : L[i] = m + 1;
          fl |= (L[i] < R[i]);
        }
      }
      if (!fl) {
        break;
      }
    }
    L (i, 1, n) {
      if (need[i]) {
        a[i][L[i]] = 1;
      }
    }
    rep();
  }
}

void slv () {
  #ifdef DEBUG
  start();
  #else
  cin >> n;
  #endif
  L (i, 1, n) {
    L (j, 1, n) {
      a[i][j] = 0;
    }
  }
  clr();
  L (i, 2, n) {
    C[i][1] = C[i][i] = 1;
  }
  ask();
  if (!C[1][1]) {
    BF1::main(1);
    return;
  }
  L (i, 1, n) {
    L (j, 1, n) {
      c1[i][j] = C[i][j];
    }
  }
  bool fl = 0;
  L (i, 2, n) {
    if (!c1[i][i]) {
      fl = 1;
      break;
    }
  }
  if (!fl) {
    BF2::main();
    return;
  }
  clr();
  L (i, 1, n) {
    if (c1[i][i]) {
      C[i][1] = 1;
    } else {
      C[i][i] = C[1][i] = 1;
    }
  }
  ask();
  L (i, 1, n) {
    L (j, 1, n) {
      c2[i][j] = C[i][j];
    }
  }
  L (i, 2, n) {
    if (!c1[i][i] && !c2[i][1]) {
      BF1::main(i);
      return;
    }
  }
  fl = 0;
  L (i, 2, n) {
    if (!c1[i][i] && c2[i][i]) {
      a[1][i] = 1;
      fl = 1;
    }
  }
  if (!fl) {
    L (i, 2, n) {
      if (!c1[i][i] && c2[1][i]) {
        fl = 1;
        a[1][1] = 1;
        break;
      }
    }
  }
  BF3::clr();
  if (fl) {
    BF3::vis[1] = 1;
  } else {
    BF3::need[1] = 1;
  }
  L (i, 2, n) {
    if (!c1[i][i]) {
      BF3::need[i] = 1;
    }
  }
  BF3::main();
}

int main () {
  ios::sync_with_stdio(0);
  int T;
  cin >> T;
  while (T--) {
    slv();
  }
}
// I love WHQ!