#pragma GCC optimize("Ofast,O3,unroll-loops")

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

#define ll long long
#define all(x) x.begin(), x.end()
#define pb push_back
#define f first
#define s second
#define ca(x) for(auto i:x) cout<<i<<" ";

#define vi vector<int>

std::random_device rd;   
std::mt19937 gen;

void shuffle_vec(vi& vec) {
	shuffle(begin(vec), end(vec), gen);
}
int n;

void query(vi &q, vi &p, int type) {
    cout<<type<<" ";
    for(int i=0; i<n; i++) {
        cout<<q[p[i]]+1<<" ";
    }
    cout<<endl;
}

vi blanks;
vi distr(vi &ans, int a, int b, int l_a, int r_a, int l_b, int r_b) {
    vi out(n,-1);
    vi new_positions(n);
    int cnt = 0;
    for(int i=0; i<n; i++) {
        cnt += (ans[i] == -1);
        if(ans[i] == -1) new_positions[cnt-1] = i;
    }
    for(int i=l_a; i<=r_a; i++) {
        out[new_positions[i]] = a;
    }
    for(int i=l_b; i<=r_b; i++) {
        out[new_positions[i]] = b;
    }
    for(int i=0; i<n; i++) {
        if(out[i] == -1) out[i] = blanks[i];
    }

    return out;
}

int main()
{
    // ios_base::sync_with_stdio(0); cin.tie(0);
    std::random_device rd;  
    std::mt19937 gen(rd()); 
    // if (fopen("input.in", "r")) {
    //     freopen("input.in", "r", stdin);
    //     freopen("output.out", "w", stdout);
    // }
    int x;
    cin>>n;
    vi pos(n);
    iota(all(pos), 0);
    shuffle_vec(pos);
    vi guess(n);
    iota(all(guess), 0);
    shuffle_vec(guess);
    vi ans(n, -1);

    if(n <= 7) {
        vector<int> perm(n);
        iota(all(perm), 0);
        do {
            query(perm, pos, 0);
            cin>>x;
            if(x == n) {
                query(perm, pos, 1);
                return 0;
            }
        } while(next_permutation(all(perm)));
        assert(1 == 0);
        return 0;
    }

    blanks = vi(n);

    for(int i=0; i<n-1; i++) {
        int a = guess[i];
        int b = guess[i+1];
        int m = n/2;
        auto d = distr(ans,a,b,0,m,m+1,n-1);
        query(d,pos,0);
        cin>>x;
        if(x == 0) {
            // means neither
            for(int i=0; i<=m; i++) blanks[i] = a;
            for(int i=m+1; i<n; i++) blanks[i] = b;
            break;
        }
        else if(x == 2) {
            for(int i=0; i<=m; i++) blanks[i] = b;
            for(int i=m+1; i<n; i++) blanks[i] = a;
            break;
        }
    }

    // now blanks is filled

    vi new_guess;
    for(auto g:guess) {
        if(g != blanks[0] && g != blanks.back()) new_guess.pb(g);
    }
    guess = new_guess;
    vi d;
    int last_a;
    int last_a_p;
    int correct = 0;
    for(int i=0; i<n-2; i+=2) {
        vi new_positions(n);
        int cnt = 0;
        for(int i=0; i<n; i++) {
            cnt += (ans[i] == -1);
            if(ans[i] == -1) new_positions[cnt-1] = i;
        }
        if(i == n-3) {
            int a = guess[i];
            int a_l = 0;
            int a_r = n-correct-1;
            while(a_l < a_r) {
                int m_a = (a_l + a_r) / 2;
                d = distr(ans, a, -1, a_l, m_a, 0, -1);
                query(d, pos, 0);
                cin>>x;
                if(x == 0) {
                    a_l = m_a+1;
                } else {
                    a_r = m_a;
                }
            }
            ans[new_positions[a_l]] = a;
            break;
        }
        int a = guess[i];
        int a_l = 0, b_l = 0;
        int a_r = n-correct-1; 
        int b_r = n-correct-1;
        int b = guess[i+1];
        while(a_l < a_r || b_l < b_r) {
            if(b_l == b_r) {
                swap(a_l, b_l);
                swap(a_r, b_r);
                swap(a, b);
            }
            int m_a = (a_l + a_r) / 2;
            int m_b = (b_l + b_r) / 2;
            // so we query a_l, m_a and m_b+1, b_r
            d = distr(ans, a, b, a_l, m_a, m_b+1, b_r);
            query(d, pos, 0);
            cin>>x;
            if(x == 0) {    
                // both invalid
                a_l = m_a + 1;
                b_r = m_b;
            }
            else if(x == 2) {
                // both valid
                a_r = m_a;
                b_l = m_b + 1;
            }
            else {   
                // only query one
                d = distr(ans, a, b, a_l, m_a, 0, -1);
                query(d, pos, 0);
                cin>>x;
                if(x == 0) {
                    // means b is valid, a invalid
                    b_l = m_b + 1;
                    a_l = m_a + 1;
                }
                else {
                    // means a is valid, b invalid
                    a_r = m_a;
                    b_r = m_b;
                }
            }
        }

        ans[new_positions[a_l]] = a;
        ans[new_positions[b_l]] = b;
        correct += 2;
    }
    for(int i=0; i<=n/2; i++) {
        if(ans[i] == -1) ans[i] = blanks.back();
    }
    for(int i=n/2+1; i<n; i++) {
        if(ans[i] == -1) ans[i] = blanks[0];
    }
    query(ans, pos, 1);
}