#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int N;

#ifdef LOCAL
vector<int> secret;
int Q;
vector<int> qs;
void gen(int seed) {
  mt19937_64 rng(seed);
  secret.resize(N);
  for (int i = 0; i < N; ++i) swap(secret[rng() % (i + 1)], secret[i] = i + 1);
  Q = 0;
  qs.assign(11, 0);
}
#endif

// answer if (!~depth)
int ask(int depth, const vector<int> &as) {
#ifdef LOCAL
  if (~depth) {
    ++Q;
    ++qs[depth];
  }
  int ret = 0;
  for (int i = 0; i < N; ++i) if (secret[i] == as[i]) ++ret;
// cerr<<COLOR("33")<<as<<": "<<ret<<COLOR()<<endl;
  if (!~depth) {
    assert(ret == N);
  }
  return ret;
#else
  printf("%d", (~depth) ? 0 : 1);
  for (int i = 0; i < N; ++i) printf(" %d", as[i]);
  puts("");
  fflush(stdout);
  if (!~depth) {
    return N;
  }
  int ret;
  scanf("%d", &ret);
  return ret;
#endif
}

#include <chrono>
#ifdef LOCAL
mt19937_64 rng(58);
#else
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
#endif
vector<int> ans;
void rec(int depth, int l, int r, vector<int> xs) {
// cerr<<"[rec] "<<depth<<" "<<l<<" "<<r<<" "<<xs<<endl;
  assert(r - l == (int)xs.size());
  if (l + 1 == r) {
    ans[l] = xs[0];
  } else {
    const int m = (l + r) / 2;
    for (int j = 0; j < r - l; ++j) swap(xs[rng() % (j + 1)], xs[j]);
// cerr<<"  xs = "<<xs<<endl;
    vector<int> sides(r - l, -1);
    vector<pair<int, int>> same;
    queue<int> que;
    for (int j = 0; j < r - l; ++j) que.push(j);
    for (; que.size() >= 2; ) {
      const int j0 = que.front(); que.pop();
      const int j1 = que.front(); que.pop();
      vector<int> as(N, xs[j0]);
      for (int i = m; i < r; ++i) as[i] = xs[j1];
      const int res = ask(depth, as);
      if (res == 0) {
        sides[j0] = 1;
        sides[j1] = 0;
      } else if (res == 1) {
        same.emplace_back(j0, j1);
        que.push(j0);
      } else if (res == 2) {
        sides[j0] = 0;
        sides[j1] = 1;
      } else {
        assert(false);
      }
    }
    reverse(same.begin(), same.end());
    for (const auto &e : same) sides[e.second] = sides[e.first];
    if (que.size()) {
      int cnt[2] = {};
      for (int j = 0; j < r - l; ++j) if (~sides[j]) ++cnt[sides[j]];
// cerr<<"  sides = "<<sides<<", cnt = ";pv(cnt,cnt+2);
      assert((cnt[0] == m - l) + (cnt[1] == r - m) == 1);
      const int s = (cnt[0] == m - l) ? 1 : 0;
      for (int j = 0; j < r - l; ++j) if (!~sides[j]) sides[j] = s;
    }
    vector<int> xss[2];
    for (int j = 0; j < r - l; ++j) xss[sides[j]].push_back(xs[j]);
    rec(depth + 1, l, m, xss[0]);
    rec(depth + 1, m, r, xss[1]);
  }
}
void solve() {
  ans.assign(N, -1);
  vector<int> xs(N);
  for (int x = 1; x <= N; ++x) xs[x - 1] = x;
  rec(0, 0, N, xs);
  ask(-1, ans);
}

#ifdef LOCAL
void stress() {
  for (N = 1; N <= 1000; N *= 10) {
    for (int seed = 0; seed < 10; ++seed) {
      gen(seed);
// cerr<<"secret = "<<secret<<endl;
      solve();
      cerr << "N = " << N << ": Q = " << Q << ", qs = " << qs << endl;
    }
  }
}
#endif

int main() {
  // stress();
  
  scanf("%d", &N);
  solve();
  return 0;
}