E. Anti-Sorting Game
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

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.

$$$^{\text{∗}}$$$A sequence $$$a$$$ is a subsequence of a sequence $$$b$$$ if $$$a$$$ can be obtained from $$$b$$$ by the deletion of several (possibly, zero or all) elements.

Interaction

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.

Example
Input
3
100


001
0101

0011
1100


0110

0011
Output


First
2 1 2


Second


First
2 2 3

3 1 3 4
Note

In the first test case, the starting string $$$s$$$ is 100. Busy Beaver chooses to move first, and sorts the subsequence $$$s_1s_2$$$: 100 $$$\to$$$ 010. From this position, Lazy Lemur is forced to sort the string, i.e. by sorting the subsequence $$$s_2s_3$$$: 010 $$$\to$$$ 001.

In the second test case, the starting string $$$s$$$ is 0101. Busy Beaver chooses to move second. Lazy Lemur may choose any of the subsequences $$$s_2s_3$$$, $$$s_1s_2s_3$$$, $$$s_2s_3s_4$$$, $$$s_1s_2s_3s_4$$$ but all of these result in the string becoming sorted: 0101 $$$\to$$$ 0011.

In the third test case, the starting string $$$s$$$ is 1100. Busy Beaver chooses to move first, and sorts the subsequence $$$s_2s_3$$$: 1100 $$$\to$$$ 1010. Then, Lazy Lemur chooses to sort the subsequence $$$s_1s_2$$$: 1010 $$$\to$$$ 0110. Then, Busy Beaver chooses to sort the subsequence $$$s_1s_3s_4$$$: 0110 $$$\to$$$ 0101. Finally, Lazy Lemur chooses to sort the subsequence $$$s_2s_3$$$: 0101 $$$\to$$$ 0011. Because Lazy Lemur sorted the string, Busy Beaver wins.