#include <bits/stdc++.h>

using namespace std;

vector< vector< int > > graph;

struct CentroidPathDecomposition
{
  struct Centroid
  {
    int ParIndex, ParDepth, Deep;
    vector< int > node;

    inline int size()
    {
      return (node.size());
    }

    inline int& operator[](int k)
    {
      return (node[k]);
    }

    inline pair< int, int > Up()
    {
      return (make_pair(ParIndex, ParDepth));
    }
  };

  vector< int > SubTreeSize, NextPath;
  vector< int > TreeIndex, TreeDepth, depth;
  vector< Centroid > Centroids;

  void dfs(int idx, int par = -1)
  {
    if(~par) depth[idx] = depth[par] + 1;
    for(auto& to : graph[idx]) {
      if(to != par) dfs(to, idx);
    }
  }

  void BuildSubTreeSize()
  {
    stack< pair< int, int > > s;
    s.emplace(0, -1);

    depth[0] = 0;
    dfs(0);

    while(!s.empty()) {
      auto p = s.top();
      if(~SubTreeSize[p.first]) {
        if(~p.second) {
          if(NextPath[p.second] == -1 || SubTreeSize[p.first] > SubTreeSize[NextPath[p.second]]) {
            NextPath[p.second] = p.first;
          }
          SubTreeSize[p.second] += SubTreeSize[p.first];
        }
        s.pop();
      } else {
        SubTreeSize[p.first] = 1;
        for(int& to : graph[p.first]) {
          if(p.second != to) {
            s.emplace(to, p.first);
          }
        }
      }
    }
  }

  void BuildPath()
  {
    stack< pair< int, int > > s;
    Centroids.push_back((Centroid) {-1, -1, 0});
    s.emplace(0, -1);
    TreeIndex[0] = 0;
    while(!s.empty()) {
      auto p = s.top();
      s.pop();
      TreeDepth[p.first] = Centroids[TreeIndex[p.first]].size();
      for(auto& to : graph[p.first]) {
        if(p.second != to) {
          if(to == NextPath[p.first]) {
            TreeIndex[to] = TreeIndex[p.first];
          } else {
            TreeIndex[to] = Centroids.size();
            Centroids.push_back(
              (Centroid) {TreeIndex[p.first], TreeDepth[p.first], Centroids[TreeIndex[p.first]].Deep + 1});
          }
          s.emplace(to, p.first);
        }
      }
      Centroids[TreeIndex[p.first]].node.push_back(p.first);
    }
  }

  void AddEdge(int x, int y)
  {
    graph[x].push_back(y);
    graph[y].push_back(x);
  }

  void Build()
  {
    BuildSubTreeSize();
    BuildPath();
  }

  inline int size()
  {
    return (Centroids.size());
  }

  inline pair< int, int > Information(int idx)
  {
    return (make_pair(TreeIndex[idx], TreeDepth[idx]));
  }

  inline Centroid& operator[](int k)
  {
    return (Centroids[k]);
  }

  inline int LCA(int a, int b) // ??????????????¨??????
  {
    int TreeIdxA, TreeDepthA, TreeIdxB, TreeDepthB;
    tie(TreeIdxA, TreeDepthA) = Information(a);
    tie(TreeIdxB, TreeDepthB) = Information(b);
    while(TreeIdxA != TreeIdxB) {
      if(Centroids[TreeIdxA].Deep > Centroids[TreeIdxB].Deep) {
        tie(TreeIdxA, TreeDepthA) = Centroids[TreeIdxA].Up();
      } else {
        tie(TreeIdxB, TreeDepthB) = Centroids[TreeIdxB].Up();
      }
    }
    if(TreeDepthA > TreeDepthB) swap(TreeDepthA, TreeDepthB);
    return (Centroids[TreeIdxA][TreeDepthA]);
  }

  CentroidPathDecomposition(int SZ)
  {
    graph.resize(SZ);
    SubTreeSize.resize(SZ, -1);
    NextPath.resize(SZ, -1);
    TreeIndex.resize(SZ);
    TreeDepth.resize(SZ);
    depth.resize(SZ);
  }

  int getDist(int a, int b);
};

int CentroidPathDecomposition::getDist(int a, int b)
{
  return (depth[a] + depth[b] - 2 * depth[LCA(a, b)]);
}

int main()
{
  int N, Q;
  scanf("%d", &N);
  CentroidPathDecomposition tree(N);
  for(int i = 0; i < N; i++) {
    int k;
    scanf("%d", &k);
    for(int j = 0; j < k; j++) {
      int c;
      scanf("%d", &c);
      graph[i].push_back(c);
    }
  }
  tree.Build();


  scanf("%d", &Q);
  for(int i = 0; i < Q; i++) {
    int u, v;
    scanf("%d %d", &u, &v);
    printf("%d\n", tree.LCA(u, v));
  }
}

Measured memory_bytes: 14668