Problem:
LCA: Lowest Common Ancestor

For a rooted tree, find the lowest common ancestor of two nodes u and v.

The given tree consists of n nodes and every node has a unique ID from 0 to n-1 where 0 is the root.

Input

n
k0 c1 c2 ... ck0
k1 c1 c2 ... ck1
:
kn-1 c1 c2 ... ckn-1
q
u1 v1
u2 v2
:
uq vq

The first line of the input includes an integer n, the number of nodes of the tree.

In the next n lines, the information of node i is given. ki is the number of children of node i, and c1, ... cki are node IDs of 1st, ... kth child of node i.

In the next line, the number of queryies q is given. In the next q lines, pairs of u and v are given as the queries.

Output

For each query, print the LCA of u and v in a line.

Constraints

1 ≤ n ≤ 100000

1 ≤ q ≤ 100000

Sample Input 1

8
3 1 2 3
2 4 5
0
0
0
2 6 7
0
0
4
4 6
4 7
4 3
5 2

Sample Output 1

1
1
0
0

Solution in Ruby (judge verdict: Time Limit Exceeded)

class Node
  attr_accessor :child, :parent
  def initialize
    @child = []
  end
end

def dfs(root, g)
  stack = [root]
  path = []
  done = {}
  while stack.size > 0
    s = stack[-1]
    flag = true
    g[s].child.each{|t|
      next if done[t]
      stack << t
      done[t] = true
      flag = false
      break
    }
    if flag
      path[s] = stack.clone
      stack.pop
    end
  end
  return path
end

$checked = {}
n = gets.to_i
g = Array.new(n){Node.new}
n.times{|i|
  g[i].child = gets.split.map(&:to_i)
  g[i].child.shift
}

path = dfs(0, g)
q = gets.to_i
q.times{
  u, v = gets.split.map(&:to_i)
  common = path[u] & path[v]
  p common[-1]
}