#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

using B = bitset<200>;

void Solve() {
  int n;
  IN(n);

  map<string, int> memo;
  auto Ask = [&](const B& b) -> int {
    string s(n, '?');
    for (int i : Rep(0, n)) {
      s[i] = char('0' + b[i]);
    }
    if (memo.contains(s)) {
      return memo[s];
    }
    OUT('?', s);
    int res;
    IN(res);
    return memo[s] = res;
  };

  vector<int> deg(n);
  for (int i : Rep(0, n)) {
    B b;
    b[i] = 1;
    deg[i] = Ask(b);
  }

  static Xorshift rand;

  vector<B> v;
  vector<int> cur;
  while (true) {
    for (int vi : Rep(0, Sz(v))) {
      if (cur[vi] == 0) {
        OUT('!', int(v[vi].count()) == n);
        return;
      }
    }
    B S = reduce(ALL(v), B{}, bit_or{});
    int i;
    do {
      i = rand.Int(0, n - 1);
    } while (S[i]);
    S[i] = 1;
    if (Ask(S) == reduce(ALL(cur)) + deg[i]) {
      v.emplace_back();
      v.back()[i] = 1;
      cur.push_back(deg[i]);
    } else {
      vector<B> nv;
      vector<int> ncur;
      B nS;
      nS[i] = 1;
      int nS_cur = deg[i];
      for (int vi = 0; vi < Sz(v);) {
        if (vi + 2 <= Sz(v)) {
          B nS2_both = nS | v[vi] | v[vi + 1];
          // どっちも離れてる
          if (Ask(nS2_both) == nS_cur + cur[vi] + cur[vi + 1]) {
            nv.push_back(v[vi]);
            ncur.push_back(cur[vi]);
            nv.push_back(v[vi + 1]);
            ncur.push_back(cur[vi + 1]);
          } else {
            B nS2_one = nS | v[vi];
            // vi が離れてる
            if (Ask(nS2_one) == nS_cur + cur[vi]) {
              // vi+1 がくっついていることが確定
              nv.push_back(v[vi]);
              ncur.push_back(cur[vi]);
              nS |= v[vi + 1];
              nS_cur = Ask(nS2_both) - cur[vi];
            } else {
              // vi はくっついている
              if (Ask(nS2_both) == Ask(nS2_one) + cur[vi + 1]) {  // vi+1 が離れているか？
                nv.push_back(v[vi + 1]);
                ncur.push_back(cur[vi + 1]);
                nS |= v[vi];
                nS_cur = Ask(nS2_both) - cur[vi + 1];
              } else {
                // どっちもくっついている
                nS = nS2_both;
                nS_cur = Ask(nS2_both);
              }
            }
          }
          vi += 2;
          continue;
        }
        B nS2 = nS | v[vi];
        int tmp = Ask(nS2);
        if (tmp == nS_cur + cur[vi]) {
          nv.push_back(v[vi]);
          ncur.push_back(cur[vi]);
        } else {
          nS = nS2;
          nS_cur = tmp;
        }
        ++vi;
      }
      v = move(nv);
      cur = move(ncur);
      v.push_back(nS);
      cur.push_back(nS_cur);
    }
  }
}

int main() {
  ios::sync_with_stdio(false);

  Solve();
}

#elif __INCLUDE_LEVEL__ == 1

#include <bits/stdc++.h>

template <class T> concept Range = std::ranges::range<T> && !std::convertible_to<T, std::string_view>;
template <class T> concept Tuple = std::__is_tuple_like<T>::value && !Range<T>;

namespace std {

istream& operator>>(istream& is, Range auto&& r) {
  for (auto&& e : r) is >> e;
  return is;
}
istream& operator>>(istream& is, Tuple auto&& t) {
  apply([&](auto&... xs) { (is >> ... >> xs); }, t);
  return is;
}

ostream& operator<<(ostream& os, Range auto&& r) {
  auto sep = "";
  for (auto&& e : r) os << exchange(sep, " ") << e;
  return os;
}
ostream& operator<<(ostream& os, Tuple auto&& t) {
  auto sep = "";
  apply([&](auto&... xs) { ((os << exchange(sep, " ") << xs), ...); }, t);
  return os;
}

}  // namespace std

class Xorshift {
 public:
  Xorshift() : Xorshift(std::chrono::steady_clock::now().time_since_epoch().count()) {}

  explicit Xorshift(uint64_t seed) {
    std::ranges::generate(x_, std::mt19937_64(seed));
  }

  uint64_t Next() {
    if (++r_ == N) {
      r_ = 0;
      for (int i = 0; i < N; ++i) {
        x_[i] ^= x_[i] << 7;
        x_[i] ^= x_[i] >> 9;
      }
    }
    return x_[r_];
  }

  int Int(int a, int b) {
    uint64_t r = Next() >> 32;
    return a + int(r * (b - a + 1) >> 32);
  }

  int64_t Int(int64_t a, int64_t b) {
    __uint128_t r = Next();
    return a + int64_t(r * (b - a + 1) >> 64);
  }

  std::array<int, 2> Int2(int a, int b) {
    auto r = std::bit_cast<std::array<uint32_t, 2>>(Next());
    int x = a + int(r[0] * uint64_t(b - a) >> 32);
    int y = a + int(r[1] * uint64_t(b - a + 1) >> 32);
    if (y == x) {
      y = b;
    } else if (y < x) {
      std::swap(x, y);
    }
    return {x, y};
  }

  double Uniform() {
    return double(Next()) / double(UINT64_MAX);
  }

  double Uniform(double a, double b) {
    return a + Uniform() * (b - a);
  }

  template <std::ranges::random_access_range R>
  void Shuffle(R&& r) {
    int n = int(std::ranges::size(r));
    for (int i = 1; i < n; ++i) {
      if (int j = Int(0, i); j < i) {
        std::ranges::swap(r[i], r[j]);
      }
    }
  }

 private:
  static constexpr int N = 8;

  std::array<uint64_t, N> x_;
  int r_ = -1;
};

using namespace std;

#define ALL(r) begin(r), end(r)
#define Rep(...) [](int l, int r) { return views::iota(min(l, r), r); }(__VA_ARGS__)
#define Sz(r) int(size(r))
#define IN(...) (cin >> forward_as_tuple(__VA_ARGS__))
#define OUT(...) (cout << forward_as_tuple(__VA_ARGS__) << '\n')

#endif  // __INCLUDE_LEVEL__ == 1