Problem: This is an interactive problem.

Khanh has n points on the Cartesian plane, denoted by a_1, a_2, …, a_n. All points' coordinates are integers between -10^9 and 10^9, inclusive. No three points are collinear. He says that these points are vertices of a convex polygon; in other words, there exists a permutation p_1, p_2, …, p_n of integers from 1 to n such that the polygon a_{p_1} a_{p_2} … a_{p_n} is convex and vertices are listed in counter-clockwise order.

Khanh gives you the number n, but hides the coordinates of his points. Your task is to guess the above permutation by asking multiple queries. In each query, you give Khanh 4 integers t, i, j, k; where either t = 1 or t = 2; and i, j, k are three distinct indices from 1 to n, inclusive. In response, Khanh tells you:

  * if t = 1, the area of the triangle a_ia_ja_k multiplied by 2. 
  * if t = 2, the sign of the cross product of two vectors \overrightarrow{a_ia_j} and \overrightarrow{a_ia_k}. 



Recall that the cross product of vector \overrightarrow{a} = (x_a, y_a) and vector \overrightarrow{b} = (x_b, y_b) is the integer x_a ⋅ y_b - x_b ⋅ y_a. The sign of a number is 1 it it is positive, and -1 otherwise. It can be proven that the cross product obtained in the above queries can not be 0.

You can ask at most 3 ⋅ n queries.

Please note that Khanh fixes the coordinates of his points and does not change it while answering your queries. You do not need to guess the coordinates. In your permutation a_{p_1}a_{p_2}… a_{p_n}, p_1 should be equal to 1 and the indices of vertices should be listed in counter-clockwise order.

Interaction

You start the interaction by reading n (3 ≤ n ≤ 1 000) — the number of vertices.

To ask a query, write 4 integers t, i, j, k (1 ≤ t ≤ 2, 1 ≤ i, j, k ≤ n) in a separate line. i, j and k should be distinct.

Then read a single integer to get the answer to this query, as explained above. It can be proven that the answer of a query is always an integer.

When you find the permutation, write a number 0. Then write n integers p_1, p_2, …, p_n in the same line.

After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:

  * fflush(stdout) or cout.flush() in C++;
  * System.out.flush() in Java;
  * flush(output) in Pascal;
  * stdout.flush() in Python;
  * see documentation for other languages.



Hack format

To hack, use the following format:

The first line contains an integer n (3 ≤ n ≤ 1 000) — the number of vertices.

The i-th of the next n lines contains two integers x_i and y_i (-10^9 ≤ x_i, y_i ≤ 10^9) — the coordinate of the point a_i.

Example

Input


6

15

-1

1

Output


1 1 4 6

2 1 5 6

2 2 1 4

0 1 3 4 2 6 5

Note

The image below shows the hidden polygon in the example:

<image>

The interaction in the example goes as below: 

  * Contestant reads n = 6. 
  * Contestant asks a query with t = 1, i = 1, j = 4, k = 6. 
  * Jury answers 15. The area of the triangle A_1A_4A_6 is 7.5. Note that the answer is two times the area of the triangle. 
  * Contestant asks a query with t = 2, i = 1, j = 5, k = 6. 
  * Jury answers -1. The cross product of \overrightarrow{A_1A_5} = (2, 2) and \overrightarrow{A_1A_6} = (4, 1) is -2. The sign of -2 is -1. 
  * Contestant asks a query with t = 2, i = 2, j = 1, k = 4. 
  * Jury answers 1. The cross product of \overrightarrow{A_2A_1} = (-5, 2) and \overrightarrow{A_2A_4} = (-2, -1) is 1. The sign of 1 is 1. 
  * Contestant says that the permutation is (1, 3, 4, 2, 6, 5). 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Point {
 public:
  T x, y;
  Point() : x(0), y(0) {}
  Point(T x_, T y_) : x(x_), y(y_) {}
  template <typename U>
  explicit Point(const Point<U>& p) : x(p.x), y(p.y) {}
  Point(const std::pair<T, T>& p) : x(p.first), y(p.second) {}
  Point(const std::complex<T>& p) : x(real(p)), y(imag(p)) {}
  explicit operator std::pair<T, T>() const { return std::pair<T, T>(x, y); }
  explicit operator std::complex<T>() const { return std::complex<T>(x, y); }
  friend std::ostream& operator<<(std::ostream& o, const Point& p) {
    return o << '(' << p.x << ',' << p.y << ')';
  }
  friend std::istream& operator>>(std::istream& i, Point& p) {
    return i >> p.x >> p.y;
  }
  friend bool operator==(const Point& a, const Point& b) {
    return a.x == b.x && a.y == b.y;
  }
  friend bool operator!=(const Point& a, const Point& b) { return !(a == b); }
  friend bool operator<(const Point& a, const Point& b) {
    return (a.x != b.x ? a.x < b.x : a.y < b.y);
  }
  friend T norm(const Point& a) { return a.x * a.x + a.y * a.y; }
  friend T abs(const Point& p) { return std::hypot(p.x, p.y); }
  friend T unit(const Point& a) {
    if (a == Point()) return a;
    return a / abs(a);
  }
  friend Point conj(const Point& a) { return Point(a.x, -a.y); }
  friend Point perp(const Point& a) { return Point(-a.y, a.x); }
  friend long double arg(const Point& p) { return atan2(p.y, p.x); }
  friend Point dir(long double angle) { return Point(cos(angle), sin(angle)); }
  Point& operator+=(const Point& p) {
    x += p.x, y += p.y;
    return *this;
  }
  Point& operator-=(const Point& p) {
    x -= p.x, y -= p.y;
    return *this;
  }
  Point& operator*=(const T& t) {
    x *= t, y *= t;
    return *this;
  }
  Point& operator/=(const T& t) {
    x /= t, y /= t;
    return *this;
  }
  Point& operator*=(const Point& t) {
    Point res = Point(x, y) * t;
    x = res.x, y = res.y;
    return *this;
  }
  Point& operator/=(const Point& t) {
    Point res = Point(x, y) / t;
    x = res.x, y = res.y;
    return *this;
  }
  friend Point operator+(const Point& a, const Point& b) {
    return Point(a.x + b.x, a.y + b.y);
  }
  friend Point operator-(const Point& a, const Point& b) {
    return Point(a.x - b.x, a.y - b.y);
  }
  friend Point operator*(const Point& a, const T& t) {
    return Point(a.x * t, a.y * t);
  }
  friend Point operator*(const T& t, const Point& a) {
    return Point(t * a.x, t * a.y);
  }
  friend Point operator/(const Point& a, const T& t) {
    return Point(a.x / t, a.y / t);
  }
  friend Point operator*(const Point& a, const Point& b) {
    return Point(a.x * b.x - a.y * b.y, a.y * b.x + a.x * b.y);
  }
  friend Point operator/(const Point& a, const Point& b) {
    return Point(a * conj(b) / norm(b));
  }
  friend T int_norm(const Point& a) { return __gcd(a.x, a.y); }
  friend T int_unit(const Point& a) {
    if (a == Point()) return a;
    return a / int_norm(a);
  }
  friend T cross(const Point& a, const Point& b) {
    return a.x * b.y - a.y * b.x;
  }
  friend T dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; }
  friend T area(const Point& a, const Point& b, const Point& c) {
    return cross(b - a, c - a);
  }
  friend Point rotation(const Point& a, const Point& b) {
    return Point(dot(a, b), cross(a, b));
  }
  friend bool same_dir(const Point& a, const Point& b) {
    return cross(a, b) == 0 && dot(a, b) > 0;
  }
  friend bool is_reflex(const Point& a, const Point& b) {
    auto c = cross(a, b);
    return c ? (c < 0) : (dot(a, b) < 0);
  }
  friend bool angle_less(const Point& base, const Point& second,
                         const Point& t) {
    int r = is_reflex(base, second) - is_reflex(base, t);
    return r ? (r < 0) : (0 < cross(second, t));
  }
  friend bool angle_cmp(const Point& base) {
    return [base](const Point& second, const Point& t) {
      return angle_less(base, second, t);
    };
  }
  friend bool angle_cmp_center(const Point& center, const Point& dir) {
    return [center, dir](const Point& second, const Point& t) -> bool {
      return angle_less(dir, second - center, t - center);
    };
  }
  friend int angle_between(const Point& second, const Point& t,
                           const Point& p) {
    if (same_dir(p, second) || same_dir(p, t)) return 0;
    return angle_less(second, p, t) ? 1 : -1;
  }
};
int main() {
  int n;
  cin >> n;
  auto query = [&](int t, int x, int y, int z) {
    cout << t << " " << y + 1 << " " << z + 1 << " " << x + 1 << endl;
    long long ret;
    cin >> ret;
    return ret;
  };
  int e1 = 0;
  int e2 = 1;
  vector<int> L, R;
  vector<long long> A(n);
  for (int i = 2; i < n; i++) {
    if (query(2, e1, i, e2) > 0) {
      R.push_back(i);
    } else {
      L.push_back(i);
    }
  }
  int nl = (int)(L).size();
  int nr = (int)(R).size();
  for (int i = 2; i < n; i++) {
    A[i] = query(1, e1, e2, i);
  }
  vector<int> hull;
  hull.push_back(e2);
  {
    sort((L).begin(), (L).end(), [&](int x, int y) { return A[x] < A[y]; });
    deque<int> d;
    int big = -1;
    if ((int)(L).size()) big = L.back();
    while ((int)(L).size()) {
      int x = L.back();
      L.pop_back();
      if ((int)(d).size() == 0) {
        d.push_back(x);
      } else {
        if (query(2, e2, x, big) > 0) {
          d.push_front(x);
        } else {
          d.push_back(x);
        }
      }
    }
    for (int x : d) hull.push_back(x);
    hull.push_back(e1);
  }
  {
    sort((R).begin(), (R).end(), [&](int x, int y) { return A[x] < A[y]; });
    deque<int> d;
    int big = -1;
    if ((int)(R).size()) big = R.back();
    while ((int)(R).size()) {
      int x = R.back();
      R.pop_back();
      if ((int)(d).size() == 0) {
        d.push_back(x);
      } else {
        if (query(2, e1, x, big) > 0) {
          d.push_front(x);
        } else {
          d.push_back(x);
        }
      }
    }
    for (int x : d) hull.emplace_back(x);
  }
  cout << 0 << " ";
  vector<int> res;
  int id = 0;
  for (int i = 0; i < n; i++) {
    if (hull[i] == 0) id = i;
  }
  for (int i = 0; i < n; i++) {
    res.emplace_back(hull[(id + i) % n]);
  }
  for (int x : res) {
    cout << x + 1 << " ";
  }
  cout << endl;
  return 0;
}