#include "chameleon.h"
#include <bits/stdc++.h>
#ifdef DEBUG
#include "../debug.h"
#else
#define debug(...) void(23)
#endif
namespace {
constexpr int max_Q = int(20000);
std::vector<int> join(std::vector<int> a, int x) {
a.emplace_back(x);
return a;
}
std::vector<int> join(std::vector<int> a, std::vector<int> x) {
a.insert(a.end(), x.begin(), x.end());
return a;
}
void erase(std::vector<int>& a, int x) {
if (std::count(a.begin(), a.end(), x)) {
a.erase(std::find(a.begin(), a.end(), x));
}
}
int cntq = 0;
int ask(std::vector<int> x) {
assert(cntq + 1 <= max_Q);
++cntq;
return Query(x);
}
} // namespace
void Solve(int N) {
std::vector<std::vector<int>> adj(2 * N + 1);
std::vector<int> col(2 * N + 1);
auto dfs = [&](auto&& self, int v) -> void {
for (auto u : adj[v]) {
if (col[u] == -1) {
col[u] = !col[v];
self(self, u);
} else {
assert(col[u] == !col[v]);
}
}
};
for (int i = 1; i <= 2 * N; ++i) {
col.assign(2 * N + 1, -1);
std::vector<int> g[2];
for (int j = 1; j < i; ++j) {
if (col[j] == -1) {
col[j] = 0;
dfs(dfs, j);
}
g[col[j]].emplace_back(j);
}
for (auto oth : g) {
for (auto j : adj[i]) {
erase(oth, j);
}
while (ask(join(oth, i)) != int(oth.size()) + 1) {
auto v = oth;
while (v.size() > 1) {
std::vector<int> lhs(v.begin(), v.begin() + v.size() / 2);
std::vector<int> rhs(v.begin() + v.size() / 2, v.end());
if (ask(join(lhs, i)) != int(lhs.size()) + 1) {
v = lhs;
} else {
v = rhs;
}
}
int x = v[0];
debug(i, x, cntq);
adj[i].emplace_back(x);
adj[x].emplace_back(i);
oth.erase(std::find(oth.begin(), oth.end(), x));
}
}
}
std::vector<std::vector<int>> res = adj;
for (int i = 1; i <= 2 * N; ++i) {
debug(i, adj[i]);
if (int(adj[i].size()) == 3) {
int x = adj[i][0];
int y = adj[i][1];
int z = adj[i][2];
if (ask({x, y, i}) == 1) {
erase(res[i], z);
erase(res[z], i);
} else if (ask({x, z, i}) == 1) {
erase(res[i], y);
erase(res[y], i);
} else {
erase(res[i], x);
erase(res[x], i);
}
}
}
debug(res);
for (int i = 1; i <= 2 * N; ++i) {
assert(int(res[i].size()) == 1);
int x = res[i][0];
if (x < i) {
Answer(x, i);
}
}
}
