from pprint import pprint
import random

DEBUG = False

if DEBUG:
    # random.seed(0)
    x = ""
    n = 1000
    A = [i for i in range(1, n + 1)]
    qc = 0
    random.shuffle(A)

    def print(Q, flush):
        # pprint(Q)

        B = list(map(int, Q.split()[1:]))

        global x, qc
        qc += 1
        if Q[0] == "1":
            pprint(f"{qc=}")
            assert qc <= 6666
            assert A == B
            exit(0)
        cnt = 0
        for a, b in zip(A, B):
            if a == b:
                cnt += 1
        x = str(cnt)

    def input():
        return x


def judge(Q):
    print(Q, flush=True)
    if Q[0] == "1":
        exit()
    return int(input())


if not DEBUG:
    n = int(input())


C = [i for i in range(1, n + 1)]
ans = [0] * n


def dfs(l, r, C):
    random.shuffle(C)
    assert r - l == len(C)
    if r - l == 1:
        ans[l] = C[0]
        return

    mid = (l + r) // 2
    L = []
    R = []
    now = [[c] for c in C]
    while now:
        nex = []
        while len(now) >= 2:
            aa = now.pop()
            a = aa[0]
            bb = now.pop()
            b = bb[0]
            Q = [a] * n
            for i in range(mid, r):
                Q[i] = b

            S = f"0 {' '.join(map(str, Q))}"
            res = judge(S)
            if res == 0:
                L.extend(bb)
                R.extend(aa)
            elif res == 1:
                aa.extend(bb)
                nex.append(aa)
            else:
                L.extend(aa)
                R.extend(bb)
        if now:
            nex.append(now.pop())
        now = nex
        # pprint(f"{len(L)=} {len(R)=} {len(now)=} {l=} {r=} {mid=}")
        if mid - l == len(L):
            for row in now:
                R.extend(row)
            break
        if r - mid == len(R):
            for row in now:
                L.extend(row)
            break

    # pprint(f"{len(L)=} {len(R)=} {l=} {r=} {mid=}")
    dfs(l, mid, L)
    dfs(mid, r, R)


dfs(0, n, C)
judge(f"1 {' '.join(map(str, ans))}")