// from: https://sio2.mimuw.edu.pl/c/pa-2019-1/s/353948/source/
#include <bits/stdc++.h>
#include "sonlib.h"

using namespace std;

const int MAX = 420;

deque<int> path;
bool examined[MAX+1];
bool reachable[MAX+1];
int visited[MAX+1];
int G[MAX][MAX];
int n;
int currentPos;

void examine() {
	Examine();
}
int move_probe(int d, int expected = -1) {
	return MoveProbe(d);
}

bool find_path() {
	for (int i = 2; i <= n; i++) {
		for (int u : path) {
			if (move_probe(u)) {
				while (path.back() != u) {
					path.pop_back();
				}
				path.push_front(1);
				reverse(path.begin(), path.end());
				return true;
			}
		}
		move_probe(1, 1);
		path.pop_front();
		path.push_back(i);
	}
	return false;
}

void solve_star() {
	examine();
	for (int i = 2; i <= n; i++) {
		move_probe(i);
		examine();
		move_probe(1);
	}
}

bool shrink_path() {
	for (auto i : path) {
		if (i == path.front()) {
			continue;
		}
		if (move_probe(i)) {
			if (i == path.back()) {
				reverse(path.begin(), path.end());
				return false;
			}
			while (path.back() != i) {
				path.pop_back();
			}
			reverse(path.begin(), path.end());
			shrink_path();
			return true;
		}
	}
	move_probe(path.front(), 1);
	path.erase(path.begin()+1);
	return true;
}

bool find_trio() {
	if (path.size() == 3) {
		return true;
	}
	int v = path[(int)path.size() - 2];
	path.erase(path.end()-2);
	for (int i = 1; i < (int)path.size() - 1; i++) {
		if (move_probe(path[i])) {
			while (path.back() != path[i]) {
				path.pop_back();
			}
			reverse(path.begin(), path.end());
			return false;
		}
	}
	if (move_probe(path.back())) {
		reverse(path.begin(), path.end());
		return find_trio();
	}
	if (move_probe(v) == 0) {
		move_probe(path.front(), 1);
		path = {path.front(), v, path.back()};
	} else {
		path = {v, path.front(), path.back()};
	}
	return true;
}

void add_edge(int a, int b) {
	G[a][b] = G[b][a] = 1;
	reachable[a] = reachable[b] = true;
}

void no_edge(int a, int b) {
	G[a][b] = G[b][a] = -1;
}

void solve_trio(int, int, int);

void solve_np(int a, int from) {
	if (visited[a] & 1) {
		return;
	}
	visited[a] |= 3;
	for (int x = 1; x <= n; x++) {
		if (reachable[x] || G[a][x] == -1) {
			continue;
		}
		if (move_probe(x)) {
			add_edge(a, x);
			solve_trio(x, a, from);
			move_probe(a, 0);
		} else {
			no_edge(a, x);
		}
	}
}

void solve_trio(int a, int b, int c) {
	if (visited[a] & 2) {
		return;
	}
	visited[a] |= 2;
	move_probe(b, 0);
	solve_np(b, a);
	move_probe(a, 1);
	move_probe(c, 0);
	if (move_probe(b)) {
		add_edge(a, c);
		move_probe(a, 0);
		solve_np(a, b);
		move_probe(b, 1);
		move_probe(c, 0);
		solve_np(c, b);
		move_probe(a, 1);
		return;
	}
	else visited[a] |= 3; 
	move_probe(a, 1);
	no_edge(a, c);
	for (int x = 1; x <= n; x++) {
		if (reachable[x] || G[a][x] == -1) {
			continue;
		}
		move_probe(x, 0);
		if (move_probe(c)) {
			add_edge(a, x);
			add_edge(x, c);
			solve_trio(c, b, a);
			move_probe(x, 0);
			solve_np(x, a);
			move_probe(a, 1);
			continue;
		}
		if (move_probe(b)) {
			add_edge(a, x);
			add_edge(x, b);
			no_edge(x, c);
			move_probe(a, 0);
			solve_np(a, b);
			move_probe(b, 1);
			move_probe(x, 0);
			solve_np(x, b);
			move_probe(a, 1);
			continue;
		}
		if (move_probe(c)) {
			no_edge(a, x);
			solve_trio(c, b, a);
			move_probe(b, 0);
			move_probe(a, 1);
			continue;
		}
		add_edge(a, x);
		solve_np(x, a);
		move_probe(a, 1);
		no_edge(x, b);
		no_edge(x, c);
	}
	if (!(visited[c] & 2)) {
		move_probe(b, 0);
		move_probe(c, 1);
		solve_trio(c, b, a);
		move_probe(b, 0);
		move_probe(a, 1);
	}
}

void dfs(int v) {
	Examine();
	examined[v] = true;
	for (int i = 1; i <= n; i++) {
		if (!examined[i] && G[v][i] == 1) {
			move_probe(i);
			dfs(i);
			move_probe(v);
		}
	}
}

int main() {
	n = GetN();
	currentPos = 1;
	for (int i = 2; i <= n; i++) {
		path.push_back(i);
	}
	if (!find_path()) {
		solve_star();
		return 0;
	}
	for (int i = 0; i < 2 * (int)path.size() - 2; i++) {
		if (shrink_path()) {
			i = 0;
		} else {
			if (i % 2) {
				path.insert(path.end()-1, path[1]);
				path.erase(path.begin()+1);
			}
		}
	}
	while (!find_trio());
	move_probe(path[1], 0);
	move_probe(path[2], 1);
	move_probe(path[1], 0);
	move_probe(path[0], 1);
	int a = path[0], b = path[1], c = path[2];
	add_edge(a, b);
	add_edge(b, c);
	solve_trio(a, b, c);
	dfs(a);
	return 0;
}