Problem: cf1368_f
Difficulty: easy
Categories: game, math
Time limit: 2000 ms, memory limit: 512 MB

This is an interactive problem.

John and his imaginary friend play a game. There are $n$ lamps arranged in a circle. Lamps are numbered $1$ through $n$ in clockwise order, that is, lamps $i$ and $i + 1$ are adjacent for any $i = 1, \ldots, n - 1$, and also lamps $n$ and $1$ are adjacent. Initially all lamps are turned off.

John and his friend take turns, with John moving first. On his turn John can choose to terminate the game, or to make a move. To make a move, John can choose any positive number $k$ and turn any $k$ lamps of his choosing on. In response to this move, John's friend will choose $k$ consecutive lamps and turn all of them off (the lamps in the range that were off before this move stay off). Note that the value of $k$ is the same as John's number on his last move. For example, if $n = 5$ and John have just turned three lamps on, John's friend may choose to turn off lamps $1, 2, 3$, or $2, 3, 4$, or $3, 4, 5$, or $4, 5, 1$, or $5, 1, 2$.

After this, John may choose to terminate or move again, and so on. However, John can not make more than $10^4$ moves.

John wants to maximize the number of lamps turned on at the end of the game, while his friend wants to minimize this number. Your task is to provide a strategy for John to achieve optimal result. Your program will play interactively for John against the jury's interactor program playing for John's friend.

Suppose there are $n$ lamps in the game. Let $R(n)$ be the number of turned on lamps at the end of the game if both players act optimally. Your program has to terminate the game with at least $R(n)$ turned on lamps within $10^4$ moves. Refer to Interaction section below for interaction details.

Interaction

Initially your program will be fed a single integer $n$ ($1 \leq n \leq 1000$) — the number of lamps in the game. Then the interactor will wait for your actions.

To make a move, print a line starting with an integer $k$ ($1 \leq k \leq n$), followed by $k$ distinct integers $l_1, \ldots, l_k$ ($1 \leq l_i \leq n$) — indices of lamps you want to turn on. The indices may be printed in any order. It is allowed to try to turn on a lamp that is already on (although this will have no effect).

If your move was invalid for any reason, or if you have made more than $10^4$ moves, the interactor will reply with a line containing a single integer $-1$. Otherwise, the reply will be a line containing a single integer $x$ ($1 \leq x \leq n)$, meaning that the response was to turn off $k$ consecutive lamps starting from $x$ in clockwise order.

To terminate the game instead of making a move, print a line containing a single integer $0$. The test will be passed if at this point there are at least $R(n)$ lamps turned on (note that neither $R(n)$, nor the verdict received are not communicated to your program in any way). This action does not count towards the number of moves (that is, it is legal to terminate the game after exactly $10^4$ moves).

To receive the correct verdict, your program should terminate immediately after printing $0$, or after receiving $-1$ as a response.

Don't forget to flush your output after every action.

Examples

Input

```
3
```

Output

```
0
```

Input

```
4

1
```

Output

```
2 1 3

0
```

Note

When $n = 3$, any John's move can be reversed, thus $R(3) = 0$, and terminating the game immediately is correct.

$R(4) = 1$, and one strategy to achieve this result is shown in the second sample case.

Blank lines in sample interactions are for clarity and should not be printed.

Non-adaptive interactor (C++):
#include "testlib.h"
#include <bits/stdc++.h>
using namespace std;

static long long queries = 0;     
static long long query_limit = 0; 

static void log_metrics() {
    try {
        tout << "queries=" << queries << "\n";
        tout << "query_limit=" << query_limit << "\n";
        tout.flush();
    } catch (...) {
        
    }
}

[[noreturn]] static void finish(TResult verdict, const string& msg) {
    log_metrics();
    quitf(verdict, "%s", msg.c_str());
}

static void sendMinusOne() {
    cout << -1 << "\n";
    cout.flush();
}

static int compute_R(int n) {
    int best = 0;
    for (int k = 1; k <= n; k++) {
        int ceil_div = (n + k - 1) / k;
        best = max(best, n - ceil_div - k + 1);
    }
    return best;
}

static int choose_adversarial_segment_start(const vector<char>& on, int n, int k) {
    
    int best_x = 1;
    int best_cnt = -1;

    for (int x = 1; x <= n; x++) {
        int cnt = 0;
        for (int t = 0; t < k; t++) {
            int idx = ((x - 1 + t) % n) + 1;
            cnt += (on[idx] != 0);
        }
        if (cnt > best_cnt) {
            best_cnt = cnt;
            best_x = x;
        }
    }
    return best_x;
}

int main(int argc, char* argv[]) {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    registerInteraction(argc, argv);
    atexit(log_metrics);

#if defined(SIGPIPE)
    signal(SIGPIPE, SIG_IGN);
#endif

    const int n = inf.readInt(1, 1000, "n");
    if (!inf.seekEof()) finish(_fail, "unexpected extra tokens in hidden input");

    query_limit = 10000;
    const long long hard_cap = max(200000LL, 10LL * max(1LL, query_limit));

    
    log_metrics();

    cout << n << "\n";
    cout.flush();

    vector<char> on(n + 1, 0);
    long long moves = 0;

    while (true) {
        long long k_ll;
        if (!(cin >> k_ll)) finish(_pe, "unexpected EOF from contestant");

        if (k_ll == 0) {
            int on_cnt = 0;
            for (int i = 1; i <= n; i++) on_cnt += (on[i] != 0);
            int R = compute_R(n);
            if (on_cnt >= R) finish(_ok, "OK");
            finish(_wa, "terminated with insufficient lamps on");
        }

        if (moves >= query_limit) {
            sendMinusOne();
            finish(_wa, "too many moves");
        }

        if (!(1 <= k_ll && k_ll <= n)) {
            sendMinusOne();
            finish(_wa, "invalid k");
        }
        int k = (int)k_ll;

        vector<int> idxs;
        idxs.reserve(k);
        vector<char> seen(n + 1, 0);
        for (int i = 0; i < k; i++) {
            long long v_ll;
            if (!(cin >> v_ll)) {
                sendMinusOne();
                finish(_pe, "malformed move payload");
            }
            if (!(1 <= v_ll && v_ll <= n)) {
                sendMinusOne();
                finish(_wa, "lamp index out of range");
            }
            int v = (int)v_ll;
            if (seen[v]) {
                sendMinusOne();
                finish(_wa, "duplicate lamp index in move");
            }
            seen[v] = 1;
            idxs.push_back(v);
        }

        
        for (int v : idxs) on[v] = 1;

        
        int x = choose_adversarial_segment_start(on, n, k);
        for (int t = 0; t < k; t++) {
            int idx = ((x - 1 + t) % n) + 1;
            on[idx] = 0;
        }

        moves++;
        queries = moves;
        if (queries > hard_cap) finish(_pe, "hard cap exceeded");

        cout << x << "\n";
        cout.flush();
    }
}


Adaptive interactor (C++):

Test generator (C++):
#include "testlib.h"
#include <bits/stdc++.h>
using namespace std;

int main(int argc, char* argv[]) {
    registerGen(argc, argv, 1);

    const long long seed = (argc >= 2) ? atoll(argv[1]) : 1;

    int n = 1000;
    if (seed == 1) n = 1;
    else if (seed == 2) n = 2;
    else if (seed == 3) n = 3;
    else if (seed <= 10) n = 10 * (int)seed;
    else n = 1000;
    n = max(1, min(1000, n));

    cout << n << "\n";
    return 0;
}