#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;
                }
            }
            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);
    while (inter.query_count <= 3498)
    {
        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;
        };
        if (not_flag < 400)
        {
            // x = rng() % n;
            x = rng() % 2 ? gmax() : gmin();
            if (minn[x] == n)
            {
                x = rng() % n;
            }
        }
        else
        {
            x = rng() % n;
        }
        y = rng() % n;

        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;
    }
    // assert(1 == 2);
    inter.answer(0);
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    // int T = 1000;
    int T = 1;
    // cin >> T;
    while (T--)
        solve();
    return 0;
}