#include <bits/stdc++.h>

using namespace std;

using int64 = long long;

template< typename data_t, typename lazy_t >
struct LCNode {
  using LP = LCNode *;

  LP l, r, p;
  int idx, sz;
  bool rev;
  data_t key, sum;
  lazy_t lazy;

  void init_node(int idx, const data_t &v) {
    this->sz = 1;
    this->idx = idx;
    this->lazy = 0;
    this->key = this->sum = v;
  }

  void update() {
    sz = 1;
    sum = key;
    if(l) sz += l->sz, sum = l->sum + sum;
    if(r) sz += r->sz, sum = sum + r->sum;
  }

  void propagate(const lazy_t &v) {
    lazy += v;
    key += v;
    sum += v * sz;
  }

  void toggle() {
    swap(l, r);
    rev ^= true;
  }

  bool is_root() {
    return !p || (p->l != this && p->r != this);
  }

  void push() {
    if(lazy) {
      if(l) l->propagate(lazy);
      if(r) r->propagate(lazy);
      lazy = 0;
    }
    if(rev) {
      if(l) l->toggle();
      if(r) r->toggle();
      rev = false;
    }
  }

  void rotr() {
    LP x = p, y = x->p;
    if((x->l = r)) r->p = x;
    r = x, x->p = this;
    x->update(), update();
    if((p = y)) {
      if(y->l == x) y->l = this;
      if(y->r == x) y->r = this;
      y->update();
    }
  }

  void rotl() {
    LP x = p, y = x->p;
    if((x->r = l)) l->p = x;
    l = x, x->p = this;
    x->update(), update();
    if((p = y)) {
      if(y->l == x) y->l = this;
      if(y->r == x) y->r = this;
      y->update();
    }
  }

  void splay() {
    push();
    while(!is_root()) {
      LP q = p;
      if(q->is_root()) {
        q->push(), push();
        if(q->l == this) rotr();
        else rotl();
      } else {
        LP r = q->p;
        r->push(), q->push(), push();
        if(r->l == q) {
          if(q->l == this) q->rotr(), rotr();
          else rotl(), rotr();
        } else {
          if(q->r == this) q->rotl(), rotl();
          else rotr(), rotl();
        }
      }
    }
  }

  LP expose() {
    LP rp = nullptr;
    for(LP cur = this; cur; cur = cur->p) {
      cur->splay();
      cur->r = rp;
      cur->update();
      rp = cur;
    }
    splay();
    return rp;
  }

  void link(LP parent) {
    expose();
    parent->expose();
    p = parent;
    parent->r = this;
  }

  void cut() {
    expose();
    LP parent = l;
    l = nullptr;
    parent->p = nullptr;
  }

  void evert() {
    expose();
    toggle();
    push();
  }

  LP lca(LP v) {
    expose();
    return v->expose();
  }

  void set_propagate(const lazy_t &x) {
    expose();
    propagate(x);
    push();
  }
};

using int64 = long long;

int main() {
  int N;
  scanf("%d", &N);
  auto f = [&](int64 x, int64 y) { return x + y; };
  auto g = [&](int64 x, int64 y, int64 z) { return x + y * z; };
  using LCTree = LCNode< int64, int64 >;
  vector< LCTree * > uku(N);
  for(int i = 0; i < N; i++) {
    uku[i] = new LCTree();
    uku[i]->init_node(i, 0);
  }
  for(int i = 0; i < N; i++) {
    int K;
    scanf("%d", &K);
    while(K--) {
      int T;
      scanf("%d", &T);
      uku[T]->link(uku[i]);
    }
  }
  int Q;
  scanf("%d", &Q);
  int64 all = 0;
  while(Q--) {
    int T;
    scanf("%d", &T);
    if(T == 0) {
      int V, W;
      scanf("%d %d", &V, &W);
      uku[V]->set_propagate(W);
      all += W;
    } else {
      int U;
      scanf("%d", &U);
      uku[U]->expose();
      printf("%lld\n", uku[U]->sum - all);
    }
  }
}


Measured memory_bytes: 11508