/**
 * 交互题，启动！
 * 考虑先把每个点到 1 的距离问一便，可以对点分层。
 * 但是我们只知道 1 和第一层之间连边的情况，下面剩的都不知道。
 * 没关系，考虑从第一层再随机一个点 p 出来，然后以这个点为根再分一次层。
 * 第一次的记作 c1[x]，第二次的记作 c2[x]，很容易通过这个找出那些 p 子树内的点。
 * 然而更下面的答案也无法确定，于是不如只问下一层的。
 * 这样每个点会被 1 问一次，又会被上一层的每个点都问一次，只要他把深度做低就很好卡。
 * 就算我随机也能卡，比如整个菊花套菊花。
 * 而且这个做法完全不管 B，显然不合理。
 * 可以把枚举单点改成集合折半问，然后可以中途剪个枝。
 */
#include <bits/stdc++.h>
template <typename T>
void read(T& x) {
    x = 0;
    bool sign = false;
    int Ch = getchar();
    for (; !isdigit(Ch); Ch = getchar()) sign |= Ch == '-';
    for (; isdigit(Ch); Ch = getchar()) x = x * 10 + (sign ? -(Ch & 15) : (Ch & 15));
}
template <typename T>
void uwrite(T x) {
    if (x > 9) uwrite(x / 10);
    putchar((x % 10) | 48);
}
template <typename T>
void write(T x) {
    if (x < 0)
        putchar('-'), uwrite(-x);
    else
        uwrite(x);
}
void write(char Ch) { putchar(Ch); }
void write(const char* Str) {
    for (; *Str; ++Str) putchar(*Str);
}
void write(char* Str) { write(static_cast<const char*>(Str)); }
template <typename... Args>
void read(Args&... args) {
    void(std::initializer_list<int>{(read(args), 0)...});
}
template <typename... Args>
void write(Args... args) {
    void(std::initializer_list<int>{(write(args), 0)...});
}
using i64 = long long;
using i32 = int;
using u64 = unsigned long long;
using u32 = unsigned int;
#include "tree.h"
i32 n;
std::mt19937 Rand(std::random_device{}() + std::chrono::steady_clock::now().time_since_epoch().count());
std::vector<i32> turn(const std::basic_string<i32>& vec) { return std::vector<i32>{vec.begin(), vec.end()}; }
std::vector<std::basic_string<i32>> G, Fa;
std::basic_string<i32> Dep;
i32 LCA(i32 u, i32 v) {
    if (Dep[u] < Dep[v]) std::swap(u, v);
    for (i32 k = Fa[u].size() - 1; ~k; --k)
        if (Dep[Fa[u][k]] >= Dep[v]) u = Fa[u][k];
    if (u == v) return u;
    for (i32 k = std::min(Fa[u].size(), Fa[v].size()) - 1; ~k; --k)
        if (Fa[u][k] != Fa[v][k]) u = Fa[u][k], v = Fa[v][k];
    return Fa[u][0];
}
i32 dist(i32 u, i32 v) { return Dep[u] + Dep[v] - (Dep[LCA(u, v)] << 1); }
i32 query(i32 x, std::basic_string<i32> v) {
    i32 ret = 0;
    for (i32 it : v) ret += dist(x, it);
    return ret;
}
void report(i32 x, i32 fa) {
    answer(x, fa), G[fa] += x;
    Fa[x] += fa;
    for (i32 k = 1; Fa[x].back(); ++k) Fa[x] += Fa[Fa[x][k - 1]][k - 1];
}
void find(std::basic_string<i32> Fa, std::basic_string<i32> Son) {
    if (Fa.empty() || Son.empty()) return;
    if (Fa.size() == 1) {
        for (i32 it : Son)
            if (ask(it, {Fa.front()}) == 1) report(it, Fa.front());
        return;
    } else if (Son.size() == 1)
        for (i32 it : Fa)
            if (ask(it, {Son.front()}) == 1) return report(Son.front(), it);
    std::shuffle(Son.begin(), Son.end(), Rand);
    i32 mid{Fa.size() >> 1};
    std::basic_string<i32> s[2]{{Fa.begin(), Fa.begin() + mid}, {Fa.begin() + mid, Fa.end()}};
    std::map<int, std::basic_string<i32>> p, d;
    for (i32 it : Son) d[ask(it, turn(s[1]))] += it;
    for (i32 it : Fa) p[query(it, s[1]) + s[1].size()] += it;
    for (auto pi : p)
        if (d.find(pi.first) != d.end()) find(pi.second, d[pi.first]);
}
void solver(i32 _n, i32 a, i32 b) {
    if (a == 50000) return;
    i32 Rt = Rand() % (n = _n) + 1;
    Dep.resize(n + 1);
    G.resize(n + 1, {}), Fa.resize(n + 1);
    std::vector<std::basic_string<i32>> cnt(n + 1, std::basic_string<int>{});
    for (i32 u = 1; u <= n; ++u) cnt[Dep[u] = ask(Rt, {u})] += u;
    for (i32 d = 0; d < n; ++d) {
        if (cnt[d + 1].empty()) break;
        find(cnt[d], cnt[d + 1]);
    }
}