#include <bits/stdc++.h>
using namespace std;

#define int long long
#define pi pair<int,int>
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lep(i,a,b) for(int i=(a); i<=(b);i++)
#define rep(i,a,b) for (int i = (a); i >= b; i--)

const int inf = 1e9 + 5;

pi query(int i) {
    cout << "> " << i << endl;
    int x, dx;
    cin >> x >> dx;
    return mp(x,dx);
}

void submit(vector<pi> sol) {
    cout << "!";
    for (auto [u, v]: sol) {
        cout << " " << u << " " << v;
    }
    cout << endl;
    string res;
    cin >> res;
}


void solve() {
    
    int n = 2501;
    vector<vector<int>> adj(n+1);
    vector<int> d(n+1);
    vector<bool> explored(n+1);
    vector<int> num_seen(n+1);
    int x;
    cin >> x;
    cin >> d[x];
    adj[x].resize(d[x]+1);
    int cur = x;
    vector<int> visited(n+1);
    vector<int> prv(n+1);
    bool test_done = false;
    while (true) {
        if (test_done) break;
    // lep(jjj,1,2) {
        // cout << "cur: " << cur << "\n";
        // cout << "d:\n";
        // lep(i,1,d[cur]) {
        //     cout << adj[cur][i] << " ";
        // }
        // cout << "\n";
        // explore arbitrary edge
        bool done = false;
        lep(i,1,d[cur]) {
            if (adj[cur][i] == 0) {
                auto [x, dd] = query(i);
                if (!d[x]) {
                    d[x] = dd;
                    adj[x].resize(d[x]+1);
                }
                adj[cur][i] = x;
                num_seen[cur]++;
                if (num_seen[cur] == d[cur]) explored[cur] = true;
                cur = x;
                // cout << "cur: " << cur << ", i: " << i << "\n";
                done = true;
                break;
            }
        }
        // cout << "done: " << done << "\n";
        if (done) continue;
        // no edges are explorable, BFS to find nearest edge
        explored[cur] = true;
        visited[cur] = true;
        queue<int> q;
        q.push(cur);
        int nxt = -1;
        bool found_v = false;
        // cout << "about to bfs\n";
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            lep(i,1,d[u]) {
                int v = adj[u][i];
                if (!visited[v]) {
                    visited[v] = true;
                    prv[v] = u;
                    q.push(v);
                }
                if (!explored[v]) {
                    nxt = v;
                    found_v = true;
                    break;
                }
            }
            if (found_v) break;
        }
        fill(visited.begin(), visited.end(), false);
        // cout << "found_v: " << found_v << "\n";
        if (!found_v) {
            // solution found
            vector<pi> sol;
            lep(i,1,n) {
                if (explored[i]) {
                    lep(j,1,d[i]) {
                        sol.pb(minmax({i,adj[i][j]}));
                    }
                }
            }
            sort(sol.begin(), sol.end());
            sol.erase(unique(sol.begin(), sol.end()), sol.end());
            submit(sol);
            test_done = true;
            break;
        }
        vector<int> path; // find path from u to v
        int w = nxt;
        path.pb(w);
        while (w != cur) {
            w = prv[w];
            path.pb(w);
        }
        path.pop_back();
        while (!path.empty()) {
            int y = path.back();
            lep(i,0,d[cur]) {
                if (adj[cur][i]==y) {
                    auto [uu,vv] = query(i);
                    assert(uu == y);
                }
            }
            cur = y;
            path.pop_back();
        }

        cur = nxt;

    }
}

signed main() {
    int t; cin >> t;
    while (t--) solve();
}