#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(c) begin(c), end(c)
#define dump(x) // cerr << __LINE__ << ":\t" #x " = " << x << endl

using Weight = int;
using Capacity = int;
struct Edge {
    int src, dst;
    Weight weight;
    Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Graph = vector<vector<Edge>>;

struct segment_tree {
    static const int INF = std::numeric_limits<int>::max();
};

class lca {
public:
    int n;
    int ss;
    vector<int> path, depth, in_order, out_order;
    segment_tree st;
    std::vector<pair<int,int>> dat;
    const pair<int,int> INF = make_pair(1000000000, 1000000000);

    lca(const Graph &g, int root)
        : n(g.size()),
          path(n*2 - 1),
          depth(n*2 - 1),
          in_order(n),
          out_order(n) {
        int k = 0;
        dfs(g, root, -1, 0, k);
        for (ss = 1; ss < n * 2 - 1; ss <<= 1);
        dat.assign(ss * 2, INF);
        for (int i = 0; i < (int)depth.size(); ++i){
            dat[ss + i] = make_pair(depth[i], i);
        }
        for (int i = ss - 1; i >= 1; --i){
            dat[i] = min(dat[i*2], dat[i*2+1]);
        }
    }

    void dfs(Graph const &g, int v, int p, int d, int &k) {
        in_order[v] = k;
        path[k] = v;
        depth[k++] = d;
        for (auto &e : g[v]) {
            if (e.dst != p) {
                dfs(g, e.dst, v, d + 1, k);
                path[k] = v;
                depth[k++] = d;
            }
        }
        out_order[v] = k - 1;
    }

    pair<int,int> range_min(int v, int w, int l, int r) const {
        if (r <= l || w == 0) return INF;
        if (r - l == w) return dat[v];
        int m = w / 2;
        return min(range_min(v * 2, m, l, std::min(r, m)),
                   range_min(v * 2 + 1, m, std::max(0, l - m), r - m));
    }

    int get(int u, int v) {
        int l = min(in_order[u], in_order[v]);
        int r = max(in_order[u], in_order[v]) + 1;
        auto res = range_min(1, ss, l, r);
        return path[res.second];
    }
};

#define int ll

const int B = 300;

int N, Q;
Graph g;
vector<tuple<int, int, int, int>> query;

int dist[100010];
vector<pair<int, int>> add_at[100010];
vector<int> stk;

void make_dist(int v, int p, int s) {
    dist[v] = s;
    for (auto &e : g[v]) {
        if (e.dst != p) {
            make_dist(e.dst, v, dist[v] + e.weight);
        }
    }
}

void add_many(int v, int p) {
    for (auto &aq : add_at[v]) {
        int k = aq.first;
        int x = aq.second;
        if (k < (int)stk.size())
            stk.rbegin()[k] += x;
    }

    int add = stk.back();
    stk.pop_back();
    for (auto &e : g[v]) {
        if (e.dst != p) {
            e.weight += add;
            add_many(e.dst, v);
        }
    }
    stk.push_back(add);

    for (auto &aq : add_at[v]) {
        int k = aq.first;
        int x = aq.second;
        if (k < (int)stk.size())
            stk.rbegin()[k] -= x;
    }
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n;
    Graph g(n);
    rep(i, n){
        int k;
        cin >> k;
        rep(j, k){
            int c;
            cin >> c;
            g[i].emplace_back(i, c, 1);
        }
    }
    lca l(g, 0);
    int q;
    cin >> q;
    rep(i, q){
        int u, v;
        cin >> u >> v;
        cout << l.get(u, v) << '\n';
    }
}

// signed main() {
//     ios::sync_with_stdio(0);
//     cin.tie(0);

//     cin >> N;
//     g.assign(N, {});
//     for (int i = 0; i < N - 1; i++) {
//         int a, b, c;
//         cin >> a >> b >> c;
//         --a;
//         --b;
//         g[a].emplace_back(a, b, c);
//         g[b].emplace_back(b, a, c);
//     }

//     lca lc(g, 0);

//     auto is_parent = [&](int p, int c) {
//         int l = lc.in_order[p], r = lc.out_order[p];
//         int x = lc.in_order[c];
//         return l <= x && x <= r;
//     };

//     cin >> Q;
//     query.resize(Q);
//     for (auto &q : query) {
//         int t;
//         cin >> t;
//         if (t == 1) {
//             int v, k, x;
//             cin >> v >> k >> x;
//             --v;
//             --k;
//             q = make_tuple(t, v, k, x);
//         } else {
//             int u, v;
//             cin >> u >> v;
//             --u;
//             --v;
//             q = make_tuple(t, u, v, -1);
//         }
//     }

//     for (int i = 0; i < Q; i += B) {
//         make_dist(0, -1, 0);

//         int left = i, right = min(Q, i + B);

//         for (int j = left; j < right; ++j) {
//             auto f = [&](int v){
//                 int res = 0;
//                 for (int jj = left; jj < j; ++jj) {
//                     int tt, add_at, k, x;
//                     tie(tt, add_at, k, x) = query[jj];
//                     if (tt == 1 && is_parent(add_at, v) &&
//                         lc.depth[v] > lc.depth[add_at] + k) {
//                         res += x;
//                     }
//                 }
//                 return res + dist[v];
//             };

//             int t, u, v;
//             tie(t, u, v, ignore) = query[j];

//             if (t == 2) {
//                 int l = lc.get(u, v);
//                 cout << f(u) + f(v) - 2*f(l) << '\n';
//             }
//         }

//         for (int j = 0; j < N; ++j) {
//             add_at[j].clear();
//         }
//         for (int j = left; j < right; ++j) {
//             int t, v, k, x;
//             tie(t, v, k, x) = query[j];
//             if (t == 1)
//                 add_at[v].push_back(make_pair(k, x));
//         }
//         stk.assign(N, 0);
//         add_many(0, -1);
//     }
// }

Measured memory_bytes: 21008