#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
template <class T> void corner(bool flg, T hoge) {
    if(flg) {
        cout << hoge << endl;
        exit(0);
    }
}
#define all(v) v.begin(), v.end()
#define inputv(v, n)                                                           \
    vl v;                                                                      \
    rep(i, n) {                                                                \
        ll x;                                                                  \
        cin >> x;                                                              \
        v.push_back(x);                                                        \
    }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N = 500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans;
struct edge {
    ll to, cost;
};
vector<edge> g[MAX_N];
vl visited,par(MAX_N,-1);

void add(ll a, ll b, ll c = 1) { g[a].push_back((edge) { b, c }); }

void resetv(void) { visited = vl(n, 0); }

vl sz(MAX_N,-1), in(MAX_N), out(MAX_N),nxt(MAX_N,0), HLcost(MAX_N, 0); // sz:size of root_

void dfs_sz(ll v = 0) {
    sz[v] = 1;
    for (auto &u : g[v]) {
        dfs_sz(u.to);
        sz[v] += sz[u.to];
        if (sz[u.to] > sz[g[v][0].to]) {
            swap(u, g[v][0]);
        }
    }
}

void dfs_hld(ll v = 0) {
    in[v] = t++;
        for (auto u : g[v]) {
            nxt[u.to] = (u.to == g[v][0].to ? nxt[v] : u.to);
            dfs_hld(u.to);
        }
    out[v] = t;
}

void HLD(ll v = 0) {
    t = 0;
    resetv();
    dfs_sz();
	dfs_hld();
}

struct LazySegmentTree {
private:
    int n;
    vector<ll> node, lazy;

public:
    LazySegmentTree(vector<ll> v) {
        int sz = (int)v.size();
        n = 1;
        while (n < sz)
            n *= 2;
        node.resize(2 * n - 1);
        lazy.resize(2 * n - 1, 0);

        for (int i = 0; i < sz; i++)
            node[i + n - 1] = v[i];
        for (int i = n - 2; i >= 0; i--)
            node[i] = node[i * 2 + 1] + node[i * 2 + 2];
    }

    // k 番目のノードについて遅延評価を行う
    void eval(int k, int l, int r) {

        // 遅延配列が空でない場合、自ノード及び子ノードへの
        // 値の伝播が起こる
        if (lazy[k] != 0) {
            node[k] += lazy[k];

            // 最下段かどうかのチェックをしよう
            // 子ノードは親ノードの 1/2 の範囲であるため、
            // 伝播させるときは半分にする
            if (r - l > 1) {
                lazy[2 * k + 1] += lazy[k] / 2;
                lazy[2 * k + 2] += lazy[k] / 2;
            }

            // 伝播が終わったので、自ノードの遅延配列を空にする
            lazy[k] = 0;
        }
    }

    void add(int a, int b, ll x, int k = 0, int l = 0, int r = -1) {
        if (r < 0)
            r = n;

        // k 番目のノードに対して遅延評価を行う
        eval(k, l, r);

        // 範囲外なら何もしない
        if (b <= l || r <= a)
            return;

        // 完全に被覆しているならば、遅延配列に値を入れた後に評価
        if (a <= l && r <= b) {
            lazy[k] += (r - l) * x;
            eval(k, l, r);
        }

        // そうでないならば、子ノードの値を再帰的に計算して、
        // 計算済みの値をもらってくる
        else {
            add(a, b, x, 2 * k + 1, l, (l + r) / 2);
            add(a, b, x, 2 * k + 2, (l + r) / 2, r);
            node[k] = node[2 * k + 1] + node[2 * k + 2];
        }
    }

    ll getsum(int a, int b, int k = 0, int l = 0, int r = -1) {
        if (r < 0)
            r = n;
        if (b <= l || r <= a)
            return 0;

        // 関数が呼び出されたら評価！
        eval(k, l, r);
        if (a <= l && r <= b)
            return node[k];
        ll vl = getsum(a, b, 2 * k + 1, l, (l + r) / 2);
        ll vr = getsum(a, b, 2 * k + 2, (l + r) / 2, r);
        return vl + vr;
    }
};

LazySegmentTree seg(vl(MAX_N,0));

void HL_add(ll v, ll x) {
    while (v != -1) {
        seg.add(in[nxt[v]], in[v]+1, x);
        v = par[nxt[v]];
    }
}
ll HL_querry(ll v) {;
    ll k = 0;
    while (v != -1) {
        k += seg.getsum(in[nxt[v]], in[v]+1);
        v = par[nxt[v]];
    }
    k-=seg.getsum(0,1);
    return k;
}



int main() {
    cin >> n;
    rep(i, n) {
        cin >> x;
        rep(j, x) {
            cin >> a;
            add(i, a, 0);
            par[a]=i;
        }
    }
    

    HLD();
    
    
    cin >> q;
    rep(i, q) {
        cin >> x;
        if (x == 0) {
        	cin>>a>>b;
            HL_add(a, b);
        }
        else {
            cin >> a;
            cout<<HL_querry(a)<<endl;
        }
    }
}


Measured memory_bytes: 62940