#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
#include <random>

using namespace std;

class UnionFind {
public:
    vector<int> parents;
    int group_count;

    UnionFind(int n) : parents(n, -1), group_count(n) {}

    int find(int x) {
        if (parents[x] < 0)
            return x;
        else
            return parents[x] = find(parents[x]);
    }

    void unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return;

        if (parents[x] > parents[y]) swap(x, y);

        parents[x] += parents[y];
        parents[y] = x;
        group_count--;
    }

    int size(int x) {
        return -parents[find(x)];
    }
};

int LOCAL = 0;
int N = 0;
int cnt = 0;
vector<int> ans;

int ask(const vector<int>& p) {
    cnt++;
    if (LOCAL) {
        for (int i : p)
            assert(1 <= i && i <= N);
        int same = 0;
        for (int i = 0; i < N; ++i)
            if (p[i] == ans[i])
                same++;
        return same;
    } else {
        cout << 0;
        for (int i : p)
            cout << " " << i;
        cout << endl;
        int same;
        cin >> same;
        return same;
    }
}

void answer(const vector<int>& p) {
    if (LOCAL) {
        assert(ans == p);
        cout << "cnt " << cnt << endl;
    } else {
        cout << 1;
        for (int i : p)
            cout << " " << i;
        cout << endl;
    }
}

void calc(int l, int r, vector<int>& rem, vector<int>& dummy, vector<int>& tmp) {
    if (rem.empty()) return;
    if (rem.size() == 1) {
        tmp[l] = rem[0];
        return;
    }

    vector<int> nL, nR;
    int mid = (l + r) / 2;

    vector<int> todo;
    while (rem.size() > 1) {
        todo.push_back(rem.back()); rem.pop_back();
        todo.push_back(rem.back()); rem.pop_back();
    }

    int sz = todo.size();
    UnionFind uf(sz);
    vector<int> seen(sz, -1);
    vector<int> Q = todo;

    todo.resize(sz);
    iota(todo.begin(), todo.end(), 0);

    while (!todo.empty()) {
        if (todo.size() >= 2) {
            int x = todo.back(); todo.pop_back();
            int y = todo.back(); todo.pop_back();
            vector<int> p = dummy;
            for (int i = l; i < mid; ++i) p[i] = Q[x];
            for (int i = mid; i < r; ++i) p[i] = Q[y];
            int s = ask(p);
            if (s == 0) {
                seen[x] = 1;
                seen[y] = 0;
            } else if (s == 2) {
                seen[x] = 0;
                seen[y] = 1;
            } else if (s == 1) {
                uf.unite(x, y);
                todo.push_back(uf.find(x));
            }
        } else {
            int x = todo.back(); todo.pop_back();
            vector<int> p = dummy;
            for (int i = l; i < mid; ++i) p[i] = Q[x];
            int s = ask(p);
            seen[x] = (s == 1 ? 0 : 1);
        }
    }

    for (int i = 0; i < sz; ++i) {
        if (seen[uf.find(i)] == 0) nL.push_back(Q[i]);
        else nR.push_back(Q[i]);
    }

    if (!rem.empty()) {
        int val = rem.back(); rem.pop_back();
        if (mid - l != nL.size())
            nL.push_back(val);
        else
            nR.push_back(val);
    }

    calc(l, mid, nL, dummy, tmp);
    calc(mid, r, nR, dummy, tmp);
}

void solve() {
    if (N == 1) {
        answer({1});
        return;
    }
    if (N == 2) {
        int s = ask({1, 2});
        if (s == 2)
            answer({1, 2});
        else
            answer({2, 1});
        return;
    }

    vector<int> dummy(N);
    iota(dummy.begin(), dummy.end(), 1);
    vector<int> p;
    while (true) {
        p = dummy;
        shuffle(p.begin(), p.end(), mt19937(random_device()()));
        int s = ask(p);
        if (s == 0) {
            dummy = p;
            break;
        }
    }

    vector<int> tmp(N, -1);
    vector<int> cand(N);
    iota(cand.begin(), cand.end(), 1);
    shuffle(cand.begin(), cand.end(), mt19937(random_device()()));

    calc(0, N, cand, dummy, tmp);
    answer(tmp);
}

int main() {
    while (true) {
        if (LOCAL) {
            N = 1000;
            ans.resize(N);
            iota(ans.begin(), ans.end(), 1);
            shuffle(ans.begin(), ans.end(), mt19937(random_device()()));
        } else {
            cin >> N;
        }

        solve();

        if (!LOCAL) exit(0);
        cnt = 0;
    }
}