Problem: This is an interactive problem.

The judge has a hidden rooted full binary tree with n leaves. A full binary tree is one where every node has either 0 or 2 children. The nodes with 0 children are called the leaves of the tree. Since this is a full binary tree, there are exactly 2n - 1 nodes in the tree. The leaves of the judge's tree has labels from 1 to n. You would like to reconstruct a tree that is isomorphic to the judge's tree. To do this, you can ask some questions.

A question consists of printing the label of three distinct leaves a1, a2, a3. Let the depth of a node be the shortest distance from the node to the root of the tree. Let LCA(a, b) denote the node with maximum depth that is a common ancestor of the nodes a and b.

Consider X = LCA(a1, a2), Y = LCA(a2, a3), Z = LCA(a3, a1). The judge will tell you which one of X, Y, Z has the maximum depth. Note, this pair is uniquely determined since the tree is a binary tree; there can't be any ties. 

More specifically, if X (or Y, Z respectively) maximizes the depth, the judge will respond with the string "X" (or "Y", "Z" respectively). 

You may only ask at most 10·n questions.

Input

The first line of input will contain a single integer n (3 ≤ n ≤ 1 000) — the number of leaves in the tree.

Output

To print the final answer, print out the string "-1" on its own line. Then, the next line should contain 2n - 1 integers. The i-th integer should be the parent of the i-th node, or -1, if it is the root.

Your answer will be judged correct if your output is isomorphic to the judge's tree. In particular, the labels of the leaves do not need to be labeled from 1 to n. Here, isomorphic means that there exists a permutation π such that node i is the parent of node j in the judge tree if and only node π(i) is the parent of node π(j) in your tree.

Interaction

To ask a question, print out three distinct integers a1, a2, a3. These integers should be between 1 and n, inclusive.

The judge will respond with a single character, either "X", "Y", "Z". 

If the string is "X" (or "Y", "Z" respectively), that means the pair (a1, a2) (or (a2, a3), (a3, a1) respectively) has the deepest LCA among the three pairs.

You may only ask a question at most 10·n times, otherwise, you will get Wrong Answer.

When you are ready to answer, print out a single integer "-1" on its own line. The next line should contain 2n - 1 integers. The i-th integer should be the parent of the i-th node, or -1, if it is the root. Do not forget to flush the final answer as well. Printing the answer does not count as asking a question.

You will get Wrong Answer verdict if 

  * Your question or answers are not in the format described in this statement. 
  * You ask strictly more than 10·n questions. 
  * Your question contains duplicate indices. 
  * Your final answer is not isomorphic to the judge tree. 



You will get Idleness Limit Exceeded if you don't print anything or if you forget to flush the output, including for the final answer (more info about flushing output below).

To flush you can use (just after printing an integer and end-of-line): 

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



If at any moment your program reads -1 as an answer, it should immediately exit normally (for example, by calling exit(0)). You will get Wrong Answer in this case, it means that you made more queries than allowed, or made an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.

Hacking To hack someone, use the following format 
    
    
      
    n  
    p_1 p_2 ... p_{2n-1}  
    

This denotes a tree where the parent of the i-th node is pi (pi = - 1 or n < pi ≤ 2n - 1). If pi is equal to -1, then node i is the root. This input must describe a valid full rooted binary tree.

Of course, contestant programs will not be able to see this input.

Example

Input

5
X
Z
Y
Y
X<span class="tex-font-style-tt"></span>


Output

1 4 2
1 2 4
2 4 1
2 3 5
2 4 3
-1
-1 1 1 2 2 3 3 6 6

Note

For the first sample, the judge has the hidden tree:

<image>

Here is a more readable format of the interaction: 

<image> The last line can also be 8 6 9 8 9 7 -1 6 7. 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
inline int query(int x, int y, int z) {
  printf("%d %d %d\n", x, y, z);
  fflush(stdout);
  std::string c;
  std::cin >> c;
  if (c == "X") return 1;
  if (c == "Y") return 2;
  if (c == "Z") return 3;
}
int n, last;
int papa[1 + 2 * 1000];
int left[1 + 2 * 1000], right[1 + 2 * 1000];
int l[1 + 2 * 1000], r[1 + 2 * 1000];
int seen[1 + 2 * 1000];
std::vector<int> G[1 + 2 * 1000];
int total, mainRoot, w[1 + 2 * 1000];
void weight(int node, int fth, int index) {
  total++;
  w[node] = 1;
  for (auto y : G[node])
    if (y != fth && seen[y] != index) {
      weight(y, node, index);
      w[node] += w[y];
    }
}
void getRoot(int node, int fth, int index) {
  if (mainRoot) return;
  int ok = 1;
  if (fth != 0 && total - w[node] > total / 2) ok = 0;
  for (auto y : G[node])
    if (y != fth && seen[y] != index) {
      if (w[y] > total / 2) ok = 0;
      getRoot(y, node, index);
    }
  if (ok) mainRoot = node;
}
inline int centroid(int root, int index) {
  total = 0;
  weight(root, 0, index);
  mainRoot = 0;
  getRoot(root, 0, index);
  return mainRoot;
}
inline void erase(int node, int element) {
  for (int i = 0; i < G[node].size(); i++)
    if (G[node][i] == element) {
      std::swap(G[node][i], G[node].back());
      G[node].pop_back();
    }
}
inline void insert(int node, int prevPapa, int i) {
  last++;
  if (left[prevPapa] == node) {
    left[prevPapa] = last, papa[last] = prevPapa;
    left[last] = node, papa[node] = last;
    right[last] = i, papa[i] = last;
    l[last] = l[node], r[last] = i;
  } else {
    right[prevPapa] = last, papa[last] = prevPapa;
    right[last] = node, papa[node] = last;
    left[last] = i, papa[i] = last;
    r[last] = r[node], l[last] = i;
  }
  l[i] = r[i] = i;
  erase(node, prevPapa);
  erase(prevPapa, node);
  G[prevPapa].push_back(last), G[last].push_back(prevPapa);
  G[node].push_back(last), G[last].push_back(node);
  G[i].push_back(last), G[last].push_back(i);
}
int main() {
  std::cin >> n;
  last = n + 1;
  papa[1] = papa[2] = n + 1;
  left[n + 1] = l[n + 1] = 1, right[n + 1] = r[n + 1] = 2;
  l[1] = r[1] = 1;
  l[2] = r[2] = 2;
  G[1].push_back(n + 1), G[n + 1].push_back(1);
  G[2].push_back(n + 1), G[n + 1].push_back(2);
  for (int i = 3; i <= n; i++) {
    int tmpRoot = 1;
    while (true) {
      int node = centroid(tmpRoot, i);
      if (node <= n) node = papa[node];
      int ans = query(l[node], r[node], i);
      seen[node] = i;
      if (ans == 1) {
        if (papa[node] == 0 || seen[papa[node]] == i) {
          insert(node, papa[node], i);
          break;
        } else
          tmpRoot = papa[node];
      } else if (ans == 2) {
        if (right[node] <= n || seen[right[node]] == i) {
          insert(right[node], node, i);
          break;
        } else
          tmpRoot = right[node];
      } else {
        if (left[node] <= n || seen[left[node]] == i) {
          insert(left[node], node, i);
          break;
        } else
          tmpRoot = left[node];
      }
    }
  }
  printf("-1\n");
  for (int i = 1; i <= 2 * n - 1; i++) {
    if (papa[i] == 0)
      printf("%d ", -1);
    else
      printf("%d ", papa[i]);
  }
  fflush(stdout);
  return 0;
}