Problem: 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, …, 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.

For technical reasons hacks for this problem are disabled.

Interaction

Initially your program will be fed a single integer n (1 ≤ n ≤ 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 ≤ k ≤ n), followed by k distinct integers l_1, …, l_k (1 ≤ l_i ≤ 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 ≤ x ≤ 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.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.util.BitSet;
import java.io.BufferedReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author AnandOza
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        FLampsOnACircle solver = new FLampsOnACircle();
        solver.solve(1, in, out);
        out.close();
    }

    static class FLampsOnACircle {
        private static final boolean DEBUG = false;
        private InputReader in;
        private PrintWriter out;
        TreeSet<Integer> good;
        int n;
        int realN;
        int cap;
        int mod;
        BitSet board;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            this.in = in;
            this.out = out;
            realN = n = in.nextInt();

            board = new BitSet();

            int target = 0;
            for (int m = 2; m <= n; m++) {
                int a = m;
                int b = n / m;
                int cand = (a - 1) * (b - 1) + Math.max(n % a - 1, 0);

                if (cand > target) {
                    target = cand;
                    this.mod = m;
                }
            }
            if (target == 0) {
                out.println(0);
                out.flush();
                return;
            }

            good = new TreeSet<>();

            cap = Math.max(n / mod * mod, n - 1);

            for (int i = 0; i < cap; i++) {
                if (i % mod != mod - 1)
                    good.add(i);
            }

            Util.ASSERT(good.size() == target + mod - 1);

            while (good.size() >= mod) {
                int[] move = new int[mod];
                for (int i = 0; i < mod; i++) {
                    move[i] = good.pollFirst();
                }

                play(move);
            }

            out.println(0);
            out.flush();
        }

        private void play(int... i) {
            out.print(i.length);
            for (int x : i) {
                out.print(" " + (x + 1));
                board.set(x);
            }
            out.println();
            out.flush();

            print();

            int opponent = in.nextInt() - 1;
            for (int j = 0; j < i.length; j++) {
                int move = (opponent + j) % n;
                if (move % mod != mod - 1 && move < cap && board.get(move)) {
                    good.add(move);
                }
                board.clear(move);
            }

            print();
        }

        private void print() {
            if (!DEBUG)
                return;
            String debug = "";
            for (int i = 0; i < realN; i++) {
                if (board.get(i))
                    debug += 'X';
                else
                    debug += '_';
            }
            out.println(debug);
            out.flush();
        }

    }

    static class Util {
        public static void ASSERT(boolean assertion) {
            if (!assertion)
                throw new AssertionError();
        }

        private Util() {
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}