#include <algorithm>

#include <bitset>

#include <cctype>

#include <cerrno>

#include <clocale>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <limits>

#include <list>

#include <map>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <utility>

#include <vector>

#include <cwchar>

#include <cwctype>

#include <stack>

#include <limits.h>

using namespace std;

#define MAXN 10010

#define MAXLOG 20

struct Edge

{

        int to,nxt;

} e[MAXN];

int i,T,tot,n,root,x,y;

int fa[MAXN],dep[MAXN],head[MAXN],anc[MAXN][MAXLOG];

template <typename T> inline void read(T &x)

{

    int f = ; x = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }

    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

    x *= f;

}

template <typename T> inline void write(T x)

{

    if (x < )

    {

        putchar('-');

        x = -x;

    }

    if (x > ) write(x/);

    putchar(x%+'');

}

template <typename T> inline void writeln(T x)

{

    write(x);

    puts("");

}

inline void add(int x,int y)

{

        tot++;

        e[tot] = (Edge){y,head[x]};

        head[x] = tot;

}

inline void lca_init(int u)

{

        int i,v;

        anc[u][] = fa[u];

        for (i = ; i < MAXLOG; i++)

        {

                if (dep[u] <= (i << )) break;

                anc[u][i] = anc[anc[u][i-]][i-];

        }

        for (i = head[u]; i; i = e[i].nxt)

        {

                v = e[i].to;

                dep[v] = dep[u] + ;

                lca_init(v);

        }

}

inline int lca(int u,int v)

{

        int i,k;

        if (dep[u] > dep[v]) swap(u,v);

        k = dep[v] - dep[u];

        for (i = ; i < MAXLOG; i++)

        {

                if (k & ( << i))

                        v = anc[v][i];

        }

        if (u == v) return u;

        for (i = MAXLOG - ; i >= ; i--)

        {

                if (anc[u][i] != anc[v][i])

                {

                        u = anc[u][i];

                        v = anc[v][i];

                }

        }

        return fa[u];

}

int main() {

        read(T);

        while (T--)

        {

                memset(fa,,sizeof(fa));

                memset(anc,,sizeof(anc));

                read(n);

                tot = ;

                for (i = ; i <= n; i++) head[i] = ;

                for (i = ; i < n; i++)

                {

                        read(x); read(y);

                        add(x,y);

                        fa[y] = x;

                }

                for (i = ; i <= n; i++)

                {

                        if (!fa[i])

                                root = i;

                }

                dep[root] = ;

                lca_init(root);

                read(x); read(y);

                writeln(lca(x,y));

        }

        return ;

}