Busy Beaver calls an integer timely if its decimal representation has $$$2025$$$ as a contiguous substring.

Given an integer $$$N$$$, output any $$$N$$$-digit positive integer $$$X$$$ such that $$$X$$$ is timely and a perfect square. It can be shown that such an integer always exists.

Busy Beaver has a collection of $$$N$$$ sticks with integer lengths $$$a_1, a_2, \dots, a_N$$$ and wants to make a kite. To do so, he needs to choose four different sticks from his collection with lengths $$$a$$$, $$$a$$$, $$$b$$$, $$$b$$$ for some integers $$$a$$$ and $$$b$$$ (not necessarily distinct).

It might not be possible for Busy Beaver to make a kite using his current collection, but he is able to modify the sticks. In an operation, Busy Beaver can take a stick and extend its length by $$$1$$$. Compute the minimum number of operations required to construct a kite of any size. It can be shown that it's always possible to make a kite after a finite number of operations.

There are two subtasks for this problem.

• ($$$50$$$ points): The sum of $$$N$$$ across all test cases is no more than $$$2 \cdot 10^3$$$.
• ($$$50$$$ points): No additional constraints.

It's dinner time, and Busy Beaver has to feed his baby beavers.

Busy Beaver has $$$N$$$ baby beavers, numbered from $$$1$$$ to $$$N$$$. The older baby beavers have bigger indices than the younger ones; for example, beaver $$$1$$$ is the youngest while beaver $$$N$$$ is the oldest.

Busy Beaver also has $$$2N$$$ dishes, which are numbered from $$$1$$$ to $$$2N$$$. If a beaver eats dish $$$i$$$, its satisfaction will increase by $$$i$$$. Each beaver starts with $$$0$$$ satisfaction.

Now, Busy Beaver wants to distribute the dishes amongst his baby beavers subject to the following constraints:

• Each beaver should get exactly two dishes.
• After all dishes are consumed, older beavers should have at least as much satisfaction as younger beavers. Formally, for any $$$i, j$$$ with $$$1 \leq i \lt j \leq N$$$, beaver $$$i$$$'s satisfaction should not exceed beaver $$$j$$$'s satisfaction.
• The parity of beaver $$$i$$$'s satisfaction should be $$$c_i$$$ (odd or even).

Determine if there exists a way to feed all $$$N$$$ beavers that respects these constraints. Additionally, if the task is possible, print any valid assignment of dishes to beavers.

There are two subtasks for this problem.

• ($$$25$$$ points): For each test case, the string $$$c$$$ either only consists of 'O's or only consists of 'E's.
• ($$$75$$$ points): No additional constraints.

Busy Beaver wants to have a tour in Beaverland! Beaverland consists of $$$N$$$ cities and $$$M$$$ bidirectional roads between them. It is guaranteed that it is possible to travel between any pair of cities along the $$$M$$$ roads, and that all roads have length $$$1$$$.

So far, Busy Beaver has planned out his tour, and wishes to visit the cities $$$x_1, x_2, \dots, x_K$$$. He views his tour to be interesting if $$$$$$\mathrm{dist}(1,x_1) \lt \mathrm{dist}(1,x_2) \lt \dots \lt \mathrm{dist}(1,x_K)$$$$$$ where $$$\mathrm{dist}(x, y)$$$ for two cities $$$x, y$$$ is equal to the length of the shortest path connecting the two cities.

However, it might not be the case that Busy Beaver's tour is currently interesting! To fix this, he can add up to $$$5 \cdot 10^5$$$ more roads between any pairs of cities. Each of the added roads is also bidirectional and has length $$$1$$$.

Determine whether it is possible to make Busy Beaver's tour interesting by adding some roads (possibly none). Additionally, if it is possible, provide any valid construction.

This is an interactive problem.

Busy Beaver and Lazy Lemur are playing a game on a binary string $$$s$$$ that is initially not sorted. In this game, they take turns choosing some subsequence$$$^{\text{∗}}$$$ that isn't sorted, and sort it in place. Formally, they select indices $$$b_1 \lt b_2 \lt \dots \lt b_k$$$ such that the string $$$s_{b_1}s_{b_2}\dots s_{b_k}$$$ is not sorted, and sort only these characters of the original string.

It can be shown that no matter how the two players move, the string will become sorted after a finite number of turns. When this happens, the player who made the final move loses, and the other player wins.

Busy Beaver needs your help to beat Lazy Lemur. Given the starting string, determine whether or not Busy Beaver should choose to go first or second, then make a series of moves that wins against the judge.

Each test contains multiple test cases. The first line of input contains a single integer $$$T$$$ $$$(1 \leq T \leq 100)$$$, the number of test cases. The description of each test case follows.

The first line of each test case contains the string $$$s$$$ ($$$2 \leq |s| \leq 400$$$), consisting of characters '0' and/or '1'. It is guaranteed that the sum of $$$|s|$$$ over all test cases does not exceed $$$400$$$.

Afterwards, output a string that is either First or Second (case-insensitive), representing whether you wish to move first or second, respectively.

Then, your program will play against the judge.

• If it is your turn to move, output a line containing several space-separated integers $$$K$$$ $$$b_1$$$ $$$b_2$$$ $$$\dots$$$ $$$b_K$$$. The first integer $$$K$$$ ($$$1 \leq K \leq |s|$$$) indicates the length of the subsequence you will sort. Then, the next $$$K$$$ integers $$$b_1, \dots, b_K$$$ ($$$1 \leq b_1 \lt b_2 \lt \dots \lt b_K \leq |s|$$$, and $$$s_{b_1}s_{b_2}\dots s_{b_K}$$$ is not sorted) indicate the subsequence you wish to sort.
• If it is the judge's turn to move, you will receive a binary string $$$t$$$, the resulting string after the judge's move. It is guaranteed that the judge made a valid move.

Once the string becomes sorted, one of two events will happen:

• If you were the last to move, instead of the judge making a move you will receive a line containing a single integer $$$-1$$$.
• If the judge was the last to move, you will move on to the next test case, or the entire interaction ends if there are no remaining test cases.

Each time your program makes a move, do not forget to output the end of line and flush the output. Otherwise, you will get an Idleness limit exceeded verdict. To do this, use:

• fflush(stdout) or cout.flush() in C++;
• System.out.flush() in Java;
• stdout.flush() in Python.

If, at any interaction step, you read $$$-1$$$ instead of valid data, your solution must exit immediately. This means that your solution will receive a Wrong answer verdict because of an invalid query or any other mistake. Failing to exit can result in an arbitrary verdict because your solution will continue to read from a closed stream.