#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
#include <chrono>
#include<unordered_map>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(),(u).end()

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

typedef pair<int, int> PII;

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

// Przykładowe niepoprawne rozwiązanie do zadania Sonda.
// Próbujemy przejść graf w kolejności 1->2->3->4->...->n.
#include "sonlib.h"

const int MR = 410;
const int LIM = 2000;

int g[MR][MR], n, v, done[MR], cnt;

bool isClear(int nr)
{
	FORQ(i, 1, n)
		if (!g[nr][i])
			return 0;

	return 1;
}

bool isMixed(int nr)
{
	bool unknown = 0, known = 0;
	FORQ(i, 1, n)
		if (!g[nr][i])
			unknown = 1;
		else if (g[nr][i] == 1)
			known = 1;

	return unknown && known;
}

bool makeMove(int prev, int nr, bool known)
{
	int res = MoveProbe(nr);
	if (!known)
	{
		// mv % 2 == 0
		if (res)
		{
			g[prev][nr] = g[nr][prev] = 1;
			v = nr;
			return 1;
		}
		
		g[prev][nr] = g[nr][prev] = -1;
		return 0;
	}
	
	v = nr;
	return 1;
}

vector<int> V, path;
int dest;
int prv[MR];
void bfs(int nr)
{
	queue<int> Q;
	Q.push(nr);
	done[nr] = cnt;
	prv[nr] = -1;

	while (!Q.empty())
	{
		int akt = Q.front(); Q.pop();
		FORQ(i, 1, n)
			if (g[akt][i] == 1 && done[i] != cnt)
			{
				done[i] = cnt;
				prv[i] = akt;
				Q.push(i);
			}
	}

	path.clear();

	int akt = dest;
	while (akt != -1)
	{
		path.push_back(akt);
		akt = prv[akt];
	}

	reverse(path.begin(), path.end());
}

//void dfs(int nr)
//{
//	done[nr] = cnt;
//	V.push_back(nr);
//	if (nr == dest)
//		path = V;
//
//	FORQ(i, 1, n)
//		if (g[nr][i] == 1 && done[i] != cnt)
//			dfs(i);
//
//	V.pop_back();
//}

void go(int nr)
{
	done[nr] = cnt;
	Examine();
	
	FORQ(i, 1, n)
		if (g[nr][i] == 1 && done[i] != cnt)
		{
			makeMove(nr, i, 1);
			go(i);
			makeMove(i, nr, 1);
		}
}

int main() {
	n = GetN();
	FORQ(i, 1, n)
		g[i][i] = -1;

	// gdzie znajduje sie Sondka
	v = 1;

	int s = GetSubtask();

	// to mozemy zrobic - odznacz istniejace polaczenia
	g[1][2] = g[2][1] = g[1][3] = g[3][1] = g[2][3] = g[3][2] = 1;

	while (true)
	{
		// spr czy wszystkie czyste
		bool allClear = 1;
		FORQ(i, 1, n)
			if (!isClear(i))
			{
				allClear = 0;
				break;
			}
		if (allClear)
			break;

		// znajdz wierzch, ktory ma niejasne i jasne krawedzie
		// powinnismy dojsc do niego w Nparzystej liczbie ruchow
		// czyli albo dojdz do niego, albo zrob kolko 1->2->3->1 i idz
		FORQ(i, 1, n)
			if (isMixed(i))
			{
				dest = i;
				break;
			}

		// wyznacz path do dest
		cnt++;
		bfs(1);
		if (path.size() & 1)
		{
			// dodaj kolko
			reverse(path.begin(), path.end());
			path.push_back(3);
			path.push_back(2);
			path.push_back(1);
			reverse(path.begin(), path.end());
		}

		// idz po Nparzystej liczbie ruchow do dest
		FOR(i, 1, path.size())
			makeMove(path[i - 1], path[i], 1);

		// teraz jestes w dest
		// wykonaj ruch do nieznajomego
		int mv = 0;
		FORQ(i, 1, n)
			if (!g[dest][i])
			{
				mv = 1 - makeMove(dest, i, 0);
				break;
			}

		// wroc z powrotem do 1 w parzystej/Nparzystej liczbie ruchow - zalezy od testu
		dest = 1;
		cnt++;
		bfs(v);

		if (path.size() % 2 == mv)
		{
			// dodaj kolko
			path.push_back(3);
			path.push_back(2);
			path.push_back(1);
		}

		FOR(i, 1, path.size())
			makeMove(path[i - 1], path[i], 1);
	}

	// teraz mamy caly graf
	cnt++;
	go(1);
	
	return 0;
}

// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++

//#include <Processthreadsapi.h>
//#include <iostream>
//#include <Synchapi.h>
//#include <windows.h>
//#include <process.h>
//
//DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
//    main2(nullptr);
//    return 0;
//}
//int main() {
//    auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr, STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr);
//    WaitForSingleObject(h, INFINITE);
//}