output_description: For each $getSum$ query, print the sum in a line.
input_description: The input is given in the following format.
  
  $n$  
  $node_0$  
  $node_1$  
  $node_2$  
  $:$  
  $node_{n-1}$  
  $q$  
  $query_1$  
  $query_2$  
  $:$  
  $query_{q}$  
  
  The first line of the input includes an integer $n$, the number of nodes in
  the tree.
  
  In the next $n$ lines,the information of node $i$ is given in the following
  format:
  
      
      
      ki c1 c2 ... ck
      
  
  $k_i$ is the number of children of node $i$, and $c_1$ $c_2$ ... $c_{k_i}$ are
  node IDs of 1st, ... $k$th child of node $i$.
  
  In the next line, the number of queries $q$ is given. In the next $q$ lines,
  $i$th query is given in the following format:
  
      
      
      0 v w
      
  
  or
  
      
      
      1 u
      
  
  The first integer represents the type of queries.'0' denotes $add(v, w)$ and
  '1' denotes $getSum(u)$.
attempt: N = 10**5
  prt = [0] * (N + 1)
  left = [-1] + [0] * N
  right = [-1] + [0] * N
  sz = [0] + [1] * N
  key = [0] * (N + 1)
  val = [0] * (N + 1)
  rev = [0] * (N + 1)
  
  
  def update(i, l, r):
      # assert 1 <= i <= N
      sz[i] = 1 + sz[l] + sz[r]
      val[i] = key[i] + val[l] + val[r]
  
  
  def swap(i):
      if i:
          left[i], right[i] = right[i], left[i]
          rev[i] ^= 1
  
  
  def prop(i):
      swap(left[i])
      swap(right[i])
      rev[i] = 0
      return 1
  
  
  def splay(i):
      # assert 1 <= i <= N
      x = prt[i]
      rev[i] and prop(i)
  
      li = left[i]
      ri = right[i]
      while x and not left[x] != i != right[x]:
          y = prt[x]
          if not y or left[y] != x != right[y]:
              if rev[x] and prop(x):
                  li, ri = ri, li
                  swap(li)
                  swap(ri)
  
              if left[x] == i:
                  left[x] = ri
                  prt[ri] = x
                  update(x, ri, right[x])
                  ri = x
              else:
                  right[x] = li
                  prt[li] = x
                  update(x, left[x], li)
                  li = x
              x = y
              break
  
          rev[y] and prop(y)
          if rev[x] and prop(x):
              li, ri = ri, li
              swap(li)
              swap(ri)
  
          z = prt[y]
          if left[y] == x:
              if left[x] == i:
                  v = left[y] = right[x]
                  prt[v] = y
                  update(y, v, right[y])
  
                  left[x] = ri
                  right[x] = y
                  prt[ri] = x
                  update(x, ri, y)
  
                  prt[y] = ri = x
              else:
                  left[y] = ri
                  prt[ri] = y
                  update(y, ri, right[y])
  
                  right[x] = li
                  prt[li] = x
                  update(x, left[x], li)
  
                  li = x
                  ri = y
          else:
              if right[x] == i:
                  v = right[y] = left[x]
                  prt[v] = y
                  update(y, left[y], v)
  
                  left[x] = y
                  right[x] = li
                  prt[li] = x
                  update(x, y, li)
  
                  prt[y] = li = x
              else:
                  right[y] = li
                  prt[li] = y
                  update(y, left[y], li)
  
                  left[x] = ri
                  prt[ri] = x
                  update(x, ri, right[x])
  
                  li = y
                  ri = x
  
          x = z
          if left[z] == y:
              left[z] = i
              update(z, i, right[z])
          elif right[z] == y:
              right[z] = i
              update(z, left[z], i)
          else:
              break
  
      update(i, li, ri)
      left[i] = li
      right[i] = ri
      prt[li] = prt[ri] = i
      prt[i] = x
  
      rev[i] = prt[0] = 0
  
  
  def expose(i):
      p = 0
      cur = i
      while cur:
          splay(cur)
          right[cur] = p
          update(cur, left[cur], p)
          p = cur
          cur = prt[cur]
      splay(i)
      return i
  
  
  def cut(i):
      expose(i)
      p = left[i]
      left[i] = prt[p] = 0
      return p
  
  
  def link(i, p):
      expose(i)
      expose(p)
      prt[i] = p
      right[p] = i
  
  
  def evert(i):
      expose(i)
      swap(i)
      rev[i] and prop(i)
  
  
  def query(v):
      r = expose(v + 1)
      return val[r]
  
  
  def query_add(v, w):
      key[v + 1] += w
      expose(v + 1)
  
  
  readline = open(0).readline
  writelines = open(1, "w").writelines
  
  N = int(readline())
  for i in range(N):
      k, *C = map(int, readline().split())
      # for c in C:
      #    link(c+1, i+1)
      if k:
          expose(i + 1)
          for c in C:
              expose(c + 1)
              prt[c + 1] = i + 1
          right[i + 1] = C[0] + 1
  
  Q = int(readline())
  ans = []
  for q in range(Q):
      t, *args = map(int, readline().split())
      if t:
          ans.append("%d\n" % query(args[0]))
      else:
          query_add(*args)
  writelines(ans)
  
problem_description: Range Query on a Tree
  
  Write a program which manipulates a weighted rooted tree $T$ with the
  following operations:
  
    * $add(v,w)$: add $w$ to the edge which connects node $v$ and its parent  
  
    * $getSum(u)$: report the sum of weights of all edges from the root to node $u$  
  
  The given tree $T$ consists of $n$ nodes and every node has a unique ID from
  $0$ to $n-1$ respectively where ID of the root is $0$. Note that all weights
  are initialized to zero.
samples: [{"input": "6\n    2 1 2\n    2 3 5\n    0\n    0\n    0\n    1 4\n    7\n    1 1\n    0 3 10\n    1 2\n    0 4 20\n    1 3\n    0 5 40\n    1 4", "output": "0\n    0\n    10\n    60"}, {"input": "4\n    1 1\n    1 2\n    1 3\n    0\n    6\n    0 3 1000\n    0 2 1000\n    0 1 1000\n    1 1\n    1 2\n    1 3", "output": "1000\n    2000\n    3000"}, {"input": "2\n    1 1\n    0\n    4\n    0 1 1\n    1 1\n    0 1 1\n    1 1", "output": "1\n    2"}]