#include <bits/stdc++.h>
using namespace std;
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define reprrev(i,a,b) for(int i=b-1;i>=a;i--) // [a, b)
#define reprev(i,n) reprrev(i,0,n)
typedef long long ll;
typedef unsigned long long ull;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }

/* attention
    long longのシフト演算には気をつけよう
    タイポした時のデバッグが死ぬほどきつくなるので変数名は最低3字くらい使った方がいいかも
    sizeは(int)とキャストしよう
    cin.tie(0);
    ios::sync_with_stdio(false);<- これら、printfとかと併用しない方が良さそう

*/

const ll mod = 1e9+7;

void chmod(ll &M){
    if(M >= mod) M %= mod;
    else if(M < 0){
        M += (abs(M)/mod + 1)*mod;
        M %= mod;
    }
}

ll modpow(ll x, ll n){
    if(n==0) return 1;
    ll res=modpow(x, n/2);

    if(n%2==0) return res*res%mod;
    else return res*res%mod*x%mod;
}

int getl(int i, int N) { return i==0? N-1:i-1; };
int getr(int i, int N) { return i==N-1? 0:i+1; };


// 線分 ab の偏角 返り値は[-π, π]
double argument(const pair<double, double> &a, const pair<double, double> &b){
    double ax=a.first, ay=a.second, bx=b.first, by=b.second;
    return atan2(by-ay, bx-ax);
}

/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */


struct LCA {
    int n; // 頂点数
    int root; // 根
    int l; // floor(log(n))
    vector<vector<int>> const * adj; // 隣接リストへのポインタ
    vector<vector<int>> parent; // parent[k][v] := v から 2^k 個上にいった頂点の番号（根を通り過ぎるなら -1 ）
    vector<int> depth;

    // コンストラクタ
    LCA(int _n, int _root, vector<vector<int>> const * G) :n(_n), root(_root) {
        adj = G;
        l = 0;
        while((1<<l) < n) ++l;
        parent.resize(l+5, vector<int>(n, 0));
        depth.resize(n, 0);
    }

    // 深さをセットする
    void dfs(int now, int par, int dep) {
        parent[0][now] = par;
        depth[now] = dep;
        for(auto to: (*adj)[now]) if (to != par) dfs(to, now, dep+1);
    }

    // 初期化
    void init() {
        dfs(root, -1, 0);
        // parent の設定
        for(int k=0; k+1<l; ++k) {
            for(int v=0; v<n; ++v) {
                if (parent[k][v] < 0) parent[k+1][v] = -1;
                else parent[k+1][v] = parent[k][parent[k][v]];
            }
        }
    }

    // u と v の LCA を求める
    int lca(int u, int v) {
        // 深い方が v になるようにする
        // u と v の深さが同じになるまで v に先祖を辿らせる
        if (depth[u] > depth[v]) swap(u, v);
        for(int k=0; k<l; ++k) {
            if ((depth[v] - depth[u]) >> k & 1) { v = parent[k][v]; }
        }
        if (u == v) return u;
        // 二分探索で LCA を求める
        for(int k=l-1; k>=0; --k) {
            if (parent[k][u] != parent[k][v]) {
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }
};

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);

    int n; cin >> n;
    vector<vector<int>> adj(n);
    rep(i, n) {
        int k; cin >> k;
        rep(j, k) {
            int c; cin >> c;
            adj[i].push_back(c);
            adj[c].push_back(i);
        }
    }

    LCA Lca(n, 0, &adj);
    Lca.init();

    int q; cin >> q;
    while(q--) {
        int u, v; cin >> u >> v;
        cout << Lca.lca(u, v) << endl;
    }

    return 0;
}



Measured memory_bytes: 20048