\begin{problem}{Minimums on Arcs}{standard input}{standard output}{3 seconds}{1024 megabytes}

\textbf{This problem can only be solved in the C++ programming language.}

On a circle, there are $n$ distinct numbers from $1$ to $n$, with the number $p_i$ written at the $i$-th vertex when traversing counterclockwise. For each pair of values $x$ and $y$, there are two ways to get from $x$ to $y$~--- going clockwise or counterclockwise. In this problem, $n$ is always odd, so these two paths will have different lengths.

Let $f(x, y)$ be the minimum value we encounter on the way if we travel from number $x$ to number $y$ via the shortest path.

For example, if $p = [1, 5, 3, 2, 7, 4, 6]$, then the values $5$ and $7$ are connected by two paths, and the values of the vertices on these paths are, respectively, $[5, 3, 2, 7]$ and $[5, 1, 6, 4, 7]$. The shortest path is the first one mentioned, so $f(5, 7) = \min \{ 5, 3, 2, 7 \} = 2$.

We say that two permutations $p$ and $q$ are \textit{equivalent} if the value of the function $f$ for these permutations is the same for all $x$ and $y$. You are given a permutation $p$, and you need to guess any permutation $q$ that is equivalent to it by making queries to the function $f(x, y)$.

\createsection{\Grader}{Solution Format}
\Grader

This is an unusual problem. It has a testing format with a grader, where you need to implement only the function \t{guess} with the solution. This function will be called by the testing program of the jury (the grader), and the returned value of the function will be accepted as the solution to the problem.

In particular, this means that the code you submit \textbf{must not input or output any data}. Your code \textbf{must not} contain a function \t{main}. If necessary, you can implement any number of helper functions, structures, classes, and global variables, but all the code of your solution must be in one file.

You must implement the following function:

\begin{verbatim}
std::vector<int> guess(int n);
\end{verbatim}

The function \t{guess} takes as input the number $n$~--- the length of the permutation.

In the implementation of the function \t{guess}, you can use the function \t{min\_value}, which is implemented by the grader. This function takes two values $x$ and $y$ as input and returns $f(x, y)$ as the result. If an incorrect query is made or the number of queries is exhausted, the program will automatically terminate.

To access the function \t{min\_value} in your solution, the first line of your code must include the header file with the following line:

\begin{verbatim}
#include "checkpoint.h"
\end{verbatim}

The definition of the function \t{min\_value} in the header file is as follows:

\begin{verbatim}
int min_value(int x, int y);
\end{verbatim}

All parameters (values $x$, $y$, as well as the permutation $q$ you return) are given in \textbf{1-indexing}.

Your function \t{guess} must determine the unknown permutation $p$, up to the specified equivalence, using calls to the function \t{min\_value}. That is, if the jury has chosen the permutation $p$, and the function \t{guess} returns any permutation $q$ that is equivalent to it, then that answer is considered correct.

During one run of the grader, \textbf{the jury may make several calls to the function \t{guess}}, in which case the function \t{min\_value} will return the values $f(i, j)$ defined for the currently chosen permutation $p$ within the specific call to the function \t{guess}.

\textbf{The grader is not adaptive}, meaning that the permutations $p$ are fixed in advance and do not depend on the implementation of the function \t{guess}.

\createsection{\Testing}{Testing}
\Testing

You are provided with a solution template \texttt{checkpoint.cpp}, as well as a header file \texttt{checkpoint.h}, containing the definitions of the functions \t{min\_value} and \t{guess}.

For convenience in testing, you are provided with a grader~--- the file \texttt{grader.cpp}. This file implements input reading from the standard input stream, calls the function \t{guess}, and outputs the returned value of the function \t{guess} to the standard output stream. In the testing system, these grader files may differ.

To compile your code \texttt{checkpoint.cpp} in C++, use the command 
\begin{verbatim}
g++ -std=c++20 grader.cpp checkpoint.cpp -o grader
\end{verbatim}

After executing this command, an executable file named \texttt{grader} or \texttt{grader.exe} will be created, depending on your operating system. You can run this file to input tests in the specified format.

If you encounter difficulties compiling via commands, for local testing, you can copy the implementation of the function \t{guess} into the file \texttt{grader.cpp} and run the file \texttt{grader.cpp}. However, before submitting your solution to the testing system, you need to leave only the implementation of the function \t{guess}, remembering to include the header file at the beginning of the code.

\InputFile
The grader reads the test in the following format:

The first line contains the number $t$ ($1 \le t \le 30\,000$)~--- the number of input data sets.

The first line of each input data set contains an \textbf{odd} number $n$ ($1 \le n \le 30\,000$)~--- the length of the permutation.

The second line contains $n$ distinct numbers $p_1, \ldots, p_n$ ($1 \le p_i \le n$)~--- the chosen permutation.

\OutputFile
The grader outputs the results of the function \texttt{guess}~--- the guessed permutation for each input data set.

In the file \texttt{grader.cpp}, there is a variable \texttt{verbose}, which is initially set to $0$. By increasing its value, the grader will provide more detailed information about your solution and its queries.

\Example

\begin{example}
\exmpfile{example.01}{example.01.a}%
\end{example}

\Scoring
Tests for this problem consist of four groups.

Points for each of the first three groups are awarded only if all tests in the group are passed and all tests in some of the previous groups. The score for the last group equals the minimum of the scores obtained for each test in the fourth group.

For each test, let $N$ be the sum of $n$ across all input data sets, and $Q$ be the limit on the total number of calls to the function \t{min\_value} across all input data sets.

\begin{center}
\begingroup
\renewcommand{\arraystretch}{1.5}
\begin{tabular}{|c|c|c|c|c|c|}
\hline
& & \multicolumn{2}{c|}{Constraints} & & \\
\cline{3-4}
\raisebox{2.25ex}[0cm][0cm]{Group}
& \raisebox{2.25ex}[0cm][0cm]{Points}
& $N$ & $Q$
& \raisebox{2.25ex}[0cm][0cm]{\parbox{2cm}{\centering Required}}
& \raisebox{2.25ex}[0cm][0cm]{Comment}
\\
\hline
0 & 0 & -- & $Q = 4950$ & -- & Samples \\
\hline
1 & 10 & $N \le 100$ & $Q = 4950$ & & $p_{2i-1} = \frac{n-1}{2} + i$ for $1 \le i \le \frac{n+1}{2}$ \\
\hline
2 & 20 & $N \le 100$ & $Q = 4950$ & 0, 1 & \\
\hline
3 & 20 & $N \le 1\,000$ & $Q = 100\,000$ & 0, 1, 2 & \\
\hline
4 & 60 & $N \le 30\,000$ & $Q = 1\,000\,000$ & -- &  \\
\hline
\end{tabular}
\endgroup
\end{center}

The last group is scored according to the formula. If you made $x$ queries in the test, your score will be:

$$
\textrm{score} = \min \left( 60, \, \left \lfloor 95 \cdot \left( 1 - \frac{x}{10^6} \right) \right \rfloor \right)
$$

Your score for the last group equals the minimum of the scores obtained on the tests in the fourth group.

\end{problem}

