#include <bits/stdc++.h>
using namespace std;

const bool TEST = false;

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

struct interactor
{
    int n;
    int query_count;
    vector<vector<int>> G;
    int ans;
    void init()
    {
        query_count = 0;
        if (TEST)
        {
            n = 200;
            G = vector<vector<int>>(n, vector<int>(n));
            for (int i = 0; i < n; ++i)
            {
                for (int j = i + 1; j < n; ++j)
                {
                    G[i][j] = G[j][i] = 1;
                    break;

                    // int tmp = rng() % 40;
                    // int x = (tmp == 0);
                    // G[i][j] = G[j][i] = x;
                }
            }
            G[0][n - 1] = G[n - 1][0] = 1;
            // const int N = rng() % 100 + 1;
            // for (int i = N - 1; i + 1 < n; i += N)
            // {
            //     G[i][i + 1] = 0;
            //     G[i + 1][i] = 0;
            // }
            int viscnt = 0;
            vector<int> vis(n);
            auto dfs = [&](auto &self, int now) -> void
            {
                vis[now] = 1;
                viscnt++;
                for (int i = 0; i < n; ++i)
                {
                    if (!vis[i] && G[now][i] == 1)
                    {
                        self(self, i);
                    }
                }
            };
            dfs(dfs, 0);
            if (viscnt == n)
            {
                ans = 1;
            }
            else
            {
                ans = 0;
            }
        }
    }
    int readn()
    {
        if (TEST)
        {
            return n;
        }
        else
        {
            cin >> n;
            return n;
        }
    }
    int query(const string &s)
    {
        query_count++;
        if (TEST == true)
        {
            assert((int)s.size() == n);
            int cnt = 0;
            vector<int> ok(n);
            for (int i = 0; i < n; ++i) // i是否能选
            {
                if (s[i] == '1')
                {
                    continue;
                }
                for (int j = 0; j < n; ++j)
                {
                    if (i == j)
                        continue;
                    if (s[j] == '0')
                        continue;
                    if (G[i][j] == 1)
                    {
                        // cout << i << " " << j << endl;
                        ok[i] = 1;
                        cnt++;
                        break;
                    }
                }
            }
            // cout << "Q: " << s << " " << cnt << endl;
            return cnt;
        }
        else
        {
            cout << "? " << s << endl;
            int res;
            cin >> res;
            return res;
        }
    }
    void answer(int x)
    {
        if (TEST)
        {
            cout << query_count << endl;
            if (x != ans)
            {
                cout << "WA" << endl;
                cout << "ANS : " << ans << " OUT: " << x << endl;
                for (int i = 0; i < n; ++i)
                {
                    for (int j = 0; j < n; ++j)
                    {
                        cout << G[i][j] << " ";
                    }
                    cout << endl;
                }
                exit(1);
            }
            else
            {
                // cout << "AC" << endl;
            }
        }
        else
        {
            cout << "! " << x << endl;
        }
    }
    void outputG()
    {
        cout << n << endl;
        for (int i = 0; i < n; ++i)
        {
            for (int j = 0; j < n; ++j)
            {
                cout << G[i][j] << " ";
            }
            cout << endl;
        }
    }
} inter;
struct SSS
{
    set<int> st;
    int whitecnt;
    int id;
};

void solve()
{

    inter.init();
    // inter.outputG();
    int n = inter.readn();
    vector<int> fa(n);
    iota(fa.begin(), fa.end(), 0);
    vector<SSS> a(n);

    auto get_fa = [&](auto &self, int x) -> int
    {
        if (fa[x] != x)
        {
            return fa[x] = self(self, fa[x]);
        }
        else
        {
            return x;
        }
    };

    auto mergeset = [](const set<int> &s1, const set<int> &s2) -> set<int>
    {
        set<int> res;
        for (auto x : s1)
        {
            res.insert(x);
        }
        for (auto x : s2)
        {
            res.insert(x);
        }
        return res;
    };

    auto set2s = [&](const set<int> &s) -> string
    {
        string res;
        res.assign(n, '0');
        for (auto x : s)
        {
            res[x] = '1';
        }
        return res;
    };
    vector<int> SSS;
    int tot = 0;
    for (int i = 0; i < n; ++i)
    {
        set<int> setx{i};
        int res = inter.query(set2s(setx));
        if (res == 0)
        {
            inter.answer(0);
            return;
        }
        a[i].st = setx;
        a[i].whitecnt = res;
        a[i].id = ++tot;
    }
    set<pair<int, int>> vised;

    int not_flag = 0;
    vector<int> minn(n);
    int tt = 0;
    vector<int> all(n);
    iota(all.begin(), all.end(), 0);
    // random_shuffle(all.begin(), all.end());
    for (int ti = 0; ti < n; ti++)
        for (int tj = 0; tj < n; tj++)
        {
            int x = 0, y;
            // x = rng() % n;
            auto gmin = [&]()
            {
                int x = 0;
                int minwhitecnt = 1000;
                for (int i = 0; i < n; ++i)
                {
                    int fx = get_fa(get_fa, i);
                    if (a[fx].whitecnt < minwhitecnt)
                    {
                        x = i;
                        minwhitecnt = a[fx].whitecnt;
                    }
                }
                return x;
            };
            auto gmax = [&]()
            {
                int x = 0;
                int minwhitecnt = 0;
                for (int i = 0; i < n; ++i)
                {
                    int fx = get_fa(get_fa, i);
                    if (a[fx].whitecnt > minwhitecnt)
                    {
                        x = i;
                        minwhitecnt = a[fx].whitecnt;
                    }
                }
                return x;
            };

            x = all[ti];
            y = all[tj];
            while (x == y)
            {
                // x = rng() % n;
                y = rng() % n;
            }
            int fx = get_fa(get_fa, x);
            int fy = get_fa(get_fa, y);
            if (fx == fy)
                continue;
            int xid = a[fx].id;
            int yid = a[fy].id;

            auto p = make_pair(xid, yid);
            if (p.first > p.second)
            {
                swap(p.first, p.second);
            }
            if (vised.count(p))
                continue;
            // cout << x << " " << y << " " << fx << " " << fy << endl;
            set<int> newst = mergeset(a[fx].st, a[fy].st);
            int qres = inter.query(set2s(newst));
            if (qres == 0)
            {
                if ((int)newst.size() == n)
                {
                    inter.answer(1);
                    return;
                }
                else
                {
                    inter.answer(0);
                    return;
                }
            }
            if (qres == a[fx].whitecnt + a[fy].whitecnt)
            {
                vised.insert(p);
                not_flag++;
                continue;
            }
            not_flag = 0;
            fa[fx] = fy;
            a[fy].whitecnt = qres;
            for (auto x : a[fx].st)
            {
                a[fy].st.insert(x);
            }
            // cout << "merge fx=" << a[fx].id << " fy=" << a[fy].id << " newid=" << tot + 1 << endl;
            a[fy].id = ++tot;
        }
    if (TEST)
        assert(1 == 2);
    inter.answer(rng() % 2);
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int T;
    if (TEST)
        T = 1000;
    else
        T = 1;
    while (T--)
        solve();
    return 0;
}