#include <bits/stdc++.h>

using namespace std;

typedef long long i64;
typedef unsigned long long u64;
typedef double lf;

const int maxn = 210;

typedef bitset<maxn> group;

struct cmp {
    bool operator() (const group &a, const group &b) const {
        for (int i = 0; i < maxn; ++i) {
            if (a[i] != b[i]) {
                return a[i] < b[i];
            }
        }
        return false;
    }
};

map<group, int, cmp> mem;

int n;

int ask(group v) {
    if (mem.count(v)) {
        return mem[v];
    }
    string s(n, '0');
    for (int i = 0; i < n; ++i) {
        s[i] = v[i] + '0';
    }
    cout << "? " << s << endl;
    int res;
    cin >> res;
    return mem[v] = res;
}

group one_vertex(int v) {
    group res;
    res[v] = 1;
    return res;
}

bool is_close(group a, group b) {
    assert((a & b).count() == 0);
    int sa = ask(a);
    int sb = ask(b);
    int sab = ask(a | b);
    return sa + sb != sab;
}

vector<int> rec(const vector<group> &groups, const group &cur, int l, int r) {
    if (l == r) {
        return {l};
    }
    int m = (l + r) / 2;

    group left, right;
    for (int i = l; i <= m; ++i) {
        left |= groups[i];
    }
    for (int i = m + 1; i <= r; ++i) {
        right |= groups[i];
    }
    vector<int> res;
    if (is_close(cur, left)) {
        auto x = rec(groups, cur, l, m);
        res.insert(res.end(), x.begin(), x.end());
    }
    if (is_close(cur, right)) {
        auto x = rec(groups, cur, m + 1, r);
        res.insert(res.end(), x.begin(), x.end());
    }
    return res;
}

void solve() {
    cin >> n;
    vector<group> groups;

    groups.push_back(one_vertex(0));

    for (int v = 1; v < n; ++v) {
        group all;
        for (const auto &x: groups) {
            all |= x;
        }
        auto cur = one_vertex(v);
        if (!is_close(cur, all)) {
            groups.push_back(cur);
        } else {
            auto idxs = rec(groups, cur, 0, (int) groups.size() - 1);
            group new_group = cur;
            for (int idx : idxs) {
                new_group |= groups[idx];
            }
            vector<group> new_groups;
            for (int i = 0; i < (int) groups.size(); ++i) {
                if (find(idxs.begin(), idxs.end(), i) == idxs.end()) {
                    new_groups.push_back(groups[i]);
                }
            }
            new_groups.push_back(new_group);
            groups = new_groups;
        }
    }
    if (groups.size() == 1) {
        cout << "! 1" << endl;
    } else {
        cout << "! 0" << endl;
    }
}

signed main() {
// #ifndef ONLINE_JUDGE
//     freopen("input.txt", "r", stdin);
// #endif
    ios_base::sync_with_stdio(false);
    int t = 1;
    // cin >> t;
    for (int i = 0; i < t; i++) {
        solve();
    }
}