A group of $$$n$$$ friends went to Troodos mountains for hiking. Each friend has a phone, and the $$$i$$$-th phone initially has a charge of $$$a_i$$$ units. All phones are of the same model, and the maximum battery capacity for each phone is $$$M$$$ units.

They also have a single power bank with a total charge capacity of exactly $$$n \cdot M$$$ units, which is sufficient to fully charge all $$$n$$$ phones to their maximum.

However, the power bank can only be connected to one phone at a time. It can be reconnected to different phones as needed.

Friends are a bit tired, so they can't switch the power bank from one phone to another too often. The maximum number of switches is some given integer $$$S$$$.

For risk management, friends also came up with a rule that at any point in time during the charging process, the difference in charge between any two phones should not exceed $$$D$$$ units.

Your task is to find the minimum possible value of $$$D$$$ such that it is possible to fully charge all phones while satisfying both rules. Note that the answer may be non-integer and also in some cases such $$$D$$$ doesn't exist. See output section for more details.

This task contains six subtasks. To get the points for the subtask, your solution should pass all the tests in the corresponding subtask.

This is an interactive problem.

During the excavation at the ruins of the ancient city-kingdom of Salamis archaeologist found a hidden royal tomb, buried at an unknown depth of $$$n$$$ meters below the surface. Your task is to find the number $$$n$$$ by making experiments with your digging bot.

In each experiment, you give the bot a set of integer numbers $$$a_1, a_2, ..., a_k$$$, and ask it to dig from the surface (depth 0) to depth $$$n$$$, using only steps of length $$$a_i$$$. That means, if the bot's current depth is $$$x$$$, it can move to depths $$$x + a_1$$$, $$$x + a_2$$$, ..., or $$$x + a_k$$$. When the bot reaches the depth $$$n$$$, it tells you the number of steps it made. The bot is very intelligent and always makes the minimal possible number of steps to reach the depth $$$n$$$.

For example, let the hidden number be $$$n = 23$$$. If you give the bot a set $$$a = [1, 3, 8]$$$, it can reach depth $$$n$$$ in 5 steps (for example $$$0 \rightarrow 3 \rightarrow 4 \rightarrow 7 \rightarrow 15 \rightarrow 23$$$), and if you give the bot a set $$$a = [9, 5]$$$, it can reach depth $$$n$$$ in 3 steps ($$$0 \rightarrow 9 \rightarrow 18 \rightarrow 23$$$).

Your task is to guess the number $$$n$$$ after making several experiments with the following constraints:

• The hidden number $$$n$$$ is in range from 1 to 30000 (inclusive).
• The total number of experiments should be at most 20.
• The total size of sets $$$a$$$ in all experiments should be at most 250.
• In each experiment, it should be possible for the bot to reach the depth $$$n$$$.

Your solution will be tested on 100 tests. If your solution fails to guess the number $$$n$$$, or exceeds the given limits in at least one test, it will get 0 points.

If your solution successfully guesses the number $$$n$$$, and does not exceed the limits in all tests, the score will be calculated based on the total number of steps the bot made in all experiments.

Let $$$s_i$$$ be the total number of steps the bot made in all experiments in test $$$i$$$, and let $$$S$$$ be maximum of $$$s_i$$$ for all 100 tests. Then your score will be calculated based on the following table:

To make an experiment, your program should print one line of the form: "? k $$$a_1$$$ $$$a_2$$$ $$$...$$$ $$$a_k$$$", where $$$k$$$ ($$$1\le k\le 250$$$) is the size of the set and $$$a_i$$$ $$$(1 \le a_i \le 30000)$$$ are the elements of the set. After that, your program should read a single integer $$$m$$$, the minimum number of steps the bot needed to do to reach the depth $$$n$$$.

When your program is ready to guess the number $$$n$$$, it should output the following line: "! $$$n$$$". After that, your program should exit.

After printing each query do not forget to output the end of line and flush the output.

If, at any interaction step, you read $$$-1$$$ instead of valid data, your solution must exit immediately. This means that your solution will receive Wrong answer 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.

To flush, use:

• fflush(stdout) or cout.flush() in C++;
• sys.stdout.flush() in Python;
• System.out.flush() in Java;
• see the documentation for other languages.

Andreas has a tree with $$$n$$$ nodes (undirected connected graph without cycles).

Andreas and Eleni will play the following game:

• The first player chooses a starting node. (The starting node is visited at this turn)

• Then, each player, starting from the second one, chooses a node that is not already chosen and has distance$$$^{\dagger}$$$ at most $$$k$$$ from at least one of the already chosen nodes. Moreover, there should be a path that starts from the starting node (that was chosen in the first move) and passes through every node already chosen (it may also pass through non-chosen nodes).

$$${\dagger}$$$ The distance between two nodes of a tree is the length (in edges) of the shortest path between these nodes.

If there are no other nodes that can be chosen the game ends and the player who makes the last move wins.

Who will win the game if both players play optimally?

You already know that Andreas really wants to win so you need to find the answer for every starting node.