**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 2_n_ - 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 _a_1, _a_2, _a_3. 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_(_a_1, _a_2), _Y_ = _LCA_(_a_2, _a_3), _Z_ = _LCA_(_a_3, _a_1). 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 2_n_ - 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.
[samples]
## Interaction
To ask a question, print out three distinct integers _a_1, _a_2, _a_3. 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 (_a_1, _a_2) (or (_a_2, _a_3), (_a_3, _a_1) 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 2_n_ - 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 _p__i_ (_p__i_ = - 1 or _n_ < _p__i_ ≤ 2_n_ - 1). If _p__i_ 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.
## Note
For the first sample, the judge has the hidden tree:
Here is a more readable format of the interaction:
The last line can also be _8 6 9 8 9 7 -1 6 7_.
*这是一个交互式问题。*
评测机有一个包含 #cf_span[n] 个叶子的隐藏的满二叉树。满二叉树是指每个节点都有 #cf_span[0] 或 #cf_span[2] 个子节点的树。具有 #cf_span[0] 个子节点的节点称为叶子。由于这是满二叉树，树中恰好有 #cf_span[2n - 1] 个节点。评测机的树的叶子标号为 #cf_span[1] 到 #cf_span[n]。你需要重构一棵与评测机树同构的树。为此，你可以提出一些问题。
一个问题由打印三个不同的叶子标签 #cf_span[a1, a2, a3] 组成。设一个节点的 _深度_ 为该节点到树根的最短距离。设 #cf_span[LCA(a, b)] 表示同时是节点 #cf_span[a] 和 #cf_span[b] 的祖先且深度最大的节点。
考虑 #cf_span[X = LCA(a1, a2), Y = LCA(a2, a3), Z = LCA(a3, a1)]。评测机会告诉你 #cf_span[X, Y, Z] 中哪一个具有最大深度。注意，由于这是一棵二叉树，该对是唯一确定的；不可能出现平局。
更具体地说，如果 #cf_span[X]（或 #cf_span[Y]、#cf_span[Z] 分别）使深度最大，评测机会回复字符串 "_X_"（或 "_Y_"、"_Z_" 分别）。
你最多只能提出 #cf_span[10·n] 个问题。
输入的第一行包含一个整数 #cf_span[n]（#cf_span[3 ≤ n ≤ 1 000]）——树中叶子的数量。
要输出最终答案，请单独一行输出字符串 "_-1_"。然后下一行应包含 #cf_span[2n - 1] 个整数。第 #cf_span[i] 个整数应为第 #cf_span[i] 个节点的父节点，如果是根节点则为 -1。
你的答案将被判断为正确，当且仅当你的输出与评测机的树同构。特别地，叶子的标号不需要是从 #cf_span[1] 到 #cf_span[n]。这里的同构意味着存在一个排列 #cf_span[π]，使得在评测机树中节点 #cf_span[i] 是节点 #cf_span[j] 的父节点，当且仅当在你的树中节点 #cf_span[π(i)] 是节点 #cf_span[π(j)] 的父节点。
要提出一个问题，请输出三个互不相同的整数 #cf_span[a1, a2, a3]。这些整数应在 #cf_span[1] 到 #cf_span[n] 之间（包含两端）。
评测机会回复一个字符，要么是 "_X_"，要么是 "_Y_"，要么是 "_Z_"。
如果字符串是 "_X_"（或 "_Y_"、"_Z_" 分别），这意味着三对中，#cf_span[(a1, a2)]（或 #cf_span[(a2, a3)]、#cf_span[(a3, a1)] 分别）的 #cf_span[LCA] 深度最大。
你最多只能提出 #cf_span[10·n] 个问题，否则你会得到 _错误答案_。
当你准备回答时，请单独一行输出整数 "_-1_"。下一行应包含 #cf_span[2n - 1] 个整数。第 #cf_span[i] 个整数应为第 #cf_span[i] 个节点的父节点，如果是根节点则为 -1。请不要忘记刷新最终答案。输出答案不计入提问次数。
如果你出现以下情况，将得到 _错误答案_：
你的提问或答案不符合本题描述的格式。
你提问的次数严格超过 #cf_span[10·n] 次。
你的提问包含重复的索引。
你的最终答案与评测机的树不同构。
如果你没有输出任何内容，或忘记刷新输出（包括最终答案），你将得到 _怠速限制超出_（更多关于刷新输出的信息见下文）。
要刷新输出，可以在打印一个整数和换行符后使用：
在 C++ 中使用 _fflush(stdout)_；
在 Java 中使用 _System.out.flush()_；
在 Python 中使用 _stdout.flush()_；
在 Pascal 中使用 _flush(output)_；
其他语言请参阅文档。
如果你的程序在任何时刻读到 _-1_ 作为回答，应立即正常退出（例如，调用 _exit(0)_）。这种情况下你会得到 _错误答案_，表示你超出了允许的查询次数，或进行了无效查询。如果你忽略这一点，你的程序将继续从已关闭的流中读取，可能导致其他错误结果。
*黑客攻击* 要攻击某人，请使用以下格式：
np_1 p_2 ... p_{2n-1}
这表示一棵树，其中第 #cf_span[i] 个节点的父节点是 #cf_span[pi]（#cf_span[pi = - 1] 或 #cf_span[n < pi ≤ 2n - 1]）。如果 #cf_span[pi] 等于 _-1_，则节点 #cf_span[i] 是根节点。此输入必须描述一棵有效的满根二叉树。
当然，参赛程序无法看到此输入。
对于第一个样例，评测机的隐藏树为：
以下是交互的更易读格式：
## Input
输入的第一行包含一个整数 #cf_span[n]（#cf_span[3 ≤ n ≤ 1 000]）——树中叶子的数量。
## Output
要输出最终答案，请单独一行输出字符串 "_-1_"。然后下一行应包含 #cf_span[2n - 1] 个整数。第 #cf_span[i] 个整数应为第 #cf_span[i] 个节点的父节点，如果是根节点则为 -1。你的答案将被判断为正确，当且仅当你的输出与评测机的树同构。特别地，叶子的标号不需要是从 #cf_span[1] 到 #cf_span[n]。这里的同构意味着存在一个排列 #cf_span[π]，使得在评测机树中节点 #cf_span[i] 是节点 #cf_span[j] 的父节点，当且仅当在你的树中节点 #cf_span[π(i)] 是节点 #cf_span[π(j)] 的父节点。
[samples]
## Interaction
要提出一个问题，请输出三个互不相同的整数 #cf_span[a1, a2, a3]。这些整数应在 #cf_span[1] 到 #cf_span[n] 之间（包含两端）。评测机会回复一个字符，要么是 "_X_"，要么是 "_Y_"，要么是 "_Z_"。如果字符串是 "_X_"（或 "_Y_"、"_Z_" 分别），这意味着三对中，#cf_span[(a1, a2)]（或 #cf_span[(a2, a3)]、#cf_span[(a3, a1)] 分别）的 #cf_span[LCA] 深度最大。你最多只能提出 #cf_span[10·n] 个问题，否则你会得到 _错误答案_。当你准备回答时，请单独一行输出整数 "_-1_"。下一行应包含 #cf_span[2n - 1] 个整数。第 #cf_span[i] 个整数应为第 #cf_span[i] 个节点的父节点，如果是根节点则为 -1。请不要忘记刷新最终答案。输出答案不计入提问次数。如果你出现以下情况，将得到 _错误答案_：你的提问或答案不符合本题描述的格式。你提问的次数严格超过 #cf_span[10·n] 次。你的提问包含重复的索引。你的最终答案与评测机的树不同构。如果你没有输出任何内容，或忘记刷新输出（包括最终答案），你将得到 _怠速限制超出_（更多关于刷新输出的信息见下文）。要刷新输出，可以在打印一个整数和换行符后使用：在 C++ 中使用 _fflush(stdout)_；在 Java 中使用 _System.out.flush()_；在 Python 中使用 _stdout.flush()_；在 Pascal 中使用 _flush(output)_；其他语言请参阅文档。如果你的程序在任何时刻读到 _-1_ 作为回答，应立即正常退出（例如，调用 _exit(0)_）。这种情况下你会得到 _错误答案_，表示你超出了允许的查询次数，或进行了无效查询。如果你忽略这一点，你的程序将继续从已关闭的流中读取，可能导致其他错误结果。*黑客攻击* 要攻击某人，请使用以下格式：
np_1 p_2 ... p_{2n-1}
这表示一棵树，其中第 #cf_span[i] 个节点的父节点是 #cf_span[pi]（#cf_span[pi = - 1] 或 #cf_span[n < pi ≤ 2n - 1]）。如果 #cf_span[pi] 等于 _-1_，则节点 #cf_span[i] 是根节点。此输入必须描述一棵有效的满根二叉树。当然，参赛程序无法看到此输入。
## Note
对于第一个样例，评测机的隐藏树为：
以下是交互的更易读格式：
最后一行也可以是 _8 6 9 8 9 7 -1 6 7_。