#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

void Solve() {
  int n;
  IN(n);
  vector<int> a(n);
  auto Rec = [&](auto Rec, int L, int R, const vector<int>& v) -> void {
    if (L + 1 == R) {
      a[L] = v[0];
      return;
    }
    int M = midpoint(L, R);
    vector<int> vL, vR;
    queue<vector<int>> q;
    for (int e : v) {
      q.push({e});
    }
    while (Sz(q) >= 2) {
      auto x = q.front();
      q.pop();
      auto y = q.front();
      q.pop();
      vector<int> query(n, x[0]);
      fill(query.begin() + M, query.begin() + R, y[0]);
      OUT(0, query);
      int response;
      IN(response);
      if (response == 2) {
        vL.insert(vL.end(), ALL(x));
        vR.insert(vR.end(), ALL(y));
      } else if (response == 0) {
        vL.insert(vL.end(), ALL(y));
        vR.insert(vR.end(), ALL(x));
      } else {
        x.insert(x.end(), ALL(y));
        q.push(move(x));
      }
    }
    if (Sz(q) == 1) {
      for (int e : q.front()) {
        (Sz(vL) < Sz(vR) ? vL : vR).push_back(e);
      }
      q.pop();
    }
    Rec(Rec, L, M, vL);
    Rec(Rec, M, R, vR);
  };
  vector<int> v(ALL(Rep1(1, n)));
  Xorshift().Shuffle(v);
  Rec(Rec, 0, n, v);
  OUT(1, a);
}

int main() {
  ios::sync_with_stdio(false);

  Solve();
}

#elif __INCLUDE_LEVEL__ == 1

#include <bits/stdc++.h>

template <class T> concept Range = std::ranges::range<T> && !std::convertible_to<T, std::string_view>;
template <class T> concept Tuple = std::__is_tuple_like<T>::value && !Range<T>;

namespace std {

istream& operator>>(istream& is, Range auto&& r) {
  for (auto&& e : r) is >> e;
  return is;
}
istream& operator>>(istream& is, Tuple auto&& t) {
  apply([&](auto&... xs) { (is >> ... >> xs); }, t);
  return is;
}

ostream& operator<<(ostream& os, Range auto&& r) {
  auto sep = "";
  for (auto&& e : r) os << exchange(sep, " ") << e;
  return os;
}
ostream& operator<<(ostream& os, Tuple auto&& t) {
  auto sep = "";
  apply([&](auto&... xs) { ((os << exchange(sep, " ") << xs), ...); }, t);
  return os;
}

}  // namespace std

class Xorshift {
 public:
  Xorshift() : Xorshift(std::chrono::steady_clock::now().time_since_epoch().count()) {}

  explicit Xorshift(uint64_t seed) {
    std::ranges::generate(x_, std::mt19937_64(seed));
  }

  uint64_t Next() {
    if (++r_ == N) {
      r_ = 0;
      for (int i = 0; i < N; ++i) {
        x_[i] ^= x_[i] << 7;
        x_[i] ^= x_[i] >> 9;
      }
    }
    return x_[r_];
  }

  int Int(int a, int b) {
    uint64_t r = Next() >> 32;
    return a + int(r * (b - a + 1) >> 32);
  }

  int64_t Int(int64_t a, int64_t b) {
    __uint128_t r = Next();
    return a + int64_t(r * (b - a + 1) >> 64);
  }

  std::array<int, 2> Int2(int a, int b) {
    auto r = std::bit_cast<std::array<uint32_t, 2>>(Next());
    int x = a + int(r[0] * uint64_t(b - a) >> 32);
    int y = a + int(r[1] * uint64_t(b - a + 1) >> 32);
    if (y == x) {
      y = b;
    } else if (y < x) {
      std::swap(x, y);
    }
    return {x, y};
  }

  double Uniform() {
    return double(Next()) / double(UINT64_MAX);
  }

  double Uniform(double a, double b) {
    return a + Uniform() * (b - a);
  }

  template <std::ranges::random_access_range R>
  void Shuffle(R&& r) {
    int n = int(std::ranges::size(r));
    for (int i = 1; i < n; ++i) {
      if (int j = Int(0, i); j < i) {
        std::ranges::swap(r[i], r[j]);
      }
    }
  }

 private:
  static constexpr int N = 8;

  std::array<uint64_t, N> x_;
  int r_ = -1;
};

using namespace std;

#define ALL(r) begin(r), end(r)
#define Rep(...) [](int l, int r) { return views::iota(min(l, r), r); }(__VA_ARGS__)
#define Rep1(...) [](int l, int r) { return Rep(l, r + 1); }(__VA_ARGS__)
#define Sz(r) int(size(r))
#define IN(...) (cin >> forward_as_tuple(__VA_ARGS__))
#define OUT(...) (cout << forward_as_tuple(__VA_ARGS__) << '\n')

#endif  // __INCLUDE_LEVEL__ == 1