#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
// luyiming ak ioi
# include <bits/stdc++.h>
# define pii pair <int, int> 
# define mp make_pair 
using namespace std; 
using i64 = long long;
const int N = 2e5 + 5; 
int n, k; 
vector <int> g[N]; 

int dfn[N], fid[N], dep[N], siz[N], son[N], dfntot = 0, fa[N], top[N]; 
void dfs1(int x, int fa)
{
    ::fa[x] = fa; dep[x] = dep[fa] + 1, siz[x] = 1; 
    for(int v : g[x])
    {
        if(v == fa) continue; 
        dfs1(v, x); siz[x] += siz[v]; 
        if(!son[x] || siz[v] > siz[son[x]]) son[x] = v; 
    }
    return; 
}

void dfs2(int x, int _t)
{
    top[x] = _t; dfn[x] = ++dfntot, fid[dfn[x]] = x; 
    if(son[x]) dfs2(son[x], _t); 
    for(int v : g[x])
    {
        if(v == fa[x] || v == son[x]) continue; 
        dfs2(v, v); 
    }
    return; 
}

struct SgT
{
    struct node
    {
        int Minw, tagw; set <pii> S; i64 sum; 
    }T[N << 2]; 

    void pushup(int root) 
    {
        T[root].Minw = min(T[root << 1].Minw, T[root << 1 | 1].Minw); 
        // T[root].sum = T[root << 1].sum + T[root << 1 | 1].sum; 
        return; 
    }

    void pushtag(int root, int d)
    {
        T[root].Minw += d; T[root].tagw += d; return; 
    }

    void pushdown(int root)
    {
        if(!T[root].tagw) return; 
        pushtag(root << 1, T[root].tagw), pushtag(root << 1 | 1, T[root].tagw); 
        T[root].tagw = 0; 
        return; 
    }

    void build(int root, int l, int r)
    {
        if(l == r)
        {
            T[root].Minw = siz[fid[l]], T[root].tagw = T[root].sum = 0; 
            return; 
        }
        int mid = (l + r) >> 1; 
        build(root << 1, l, mid), build(root << 1 | 1, mid + 1, r); 
        pushup(root); 
        return; 
    }

    void insordel(int root, int l, int r, int x, int v, bool del = 0)
    {
        if(del) T[root].S.erase({v, fid[x]}), T[root].sum -= v; 
        else T[root].S.insert({v, fid[x]}), T[root].sum += v; 
        if(l == r) return; 
        pushdown(root); 
        int mid = (l + r) >> 1; 
        if(x <= mid) insordel(root << 1, l, mid, x, v, del); 
        else insordel(root << 1 | 1, mid + 1, r, x, v, del); 
        pushup(root); 
        return; 
    }

    void update_add(int root, int l, int r, int s, int t, int d)
    {
        // fprintf(stderr, "root = %d, l = %d, r = %d, s = %d, t = %d, d = %d\n", root, l, r, s, t, d); 
        if(l <= s && t <= r) 
        {
            pushtag(root, d); return; 
        }
        pushdown(root); 
        int mid = (s + t) >> 1; 
        if(l <= mid) update_add(root << 1, l, r, s, mid, d); 
        if(r > mid) update_add(root << 1 | 1, l, r, mid + 1, t, d); 
        pushup(root); 
        return; 
    }

    pii query(int root, int l, int r, int s, int t)
    {
        if(l <= s && t <= r) 
        {
            if(T[root].S.empty()) return mp(2e9, 0); 
            else return (*T[root].S.begin()); 
        }
        pushdown(root); 
        int mid = (s + t) >> 1; pii ans = mp(2e9, 0);  
        if(l <= mid) ans = min(ans, query(root << 1, l, r, s, mid)); 
        if(r > mid) ans = min(ans, query(root << 1 | 1, l, r, mid + 1, t)); 
        return ans; 
    }

    int query_Minw(int root, int l, int r, int s, int t)
    {
        if(T[root].Minw > 0) return -1; 
        if(s == t) return fid[s]; 
        pushdown(root); 
        int mid = (s + t) >> 1; 
        if(r <= mid) return query_Minw(root << 1, l, r, s, mid); 
        else if(l > mid) return query_Minw(root << 1 | 1, l, r, mid + 1, t); 
        else 
        {
            int lst = query_Minw(root << 1 | 1, l, r, mid + 1, t); 
            if(lst == -1) return query_Minw(root << 1, l, r, s, mid); 
            else return lst; 
        }
    }

}Tr; 

vector <pii> Seg[N << 2]; 

void Ins(int root, int l, int r, int s, int t, int x, int v)
{
    if(l <= s && t <= r) {Seg[root].emplace_back(x, v); return; }
    int mid = (s + t) >> 1; 
    if(l <= mid) Ins(root << 1, l, r, s, mid, x, v); 
    if(r > mid) Ins(root << 1 | 1, l, r, mid + 1, t, x, v); 
    return; 
}

struct Option
{
    int opt, x, d; 
    // opt = 1 表示 点x（不是 dfn） 删除 
    // opt = 2                    加入
}; 

void Upd(int x, int y, int d) // 给 path(x, y) 上的 w 加 d
{
    while(top[x] != top[y]) 
    { 
        if(dep[x] > dep[y]) swap(x, y);
        Tr.update_add(1, dfn[top[y]], dfn[y], 1, n, d); 
        y = fa[top[y]]; 
    }
    if(dfn[x] > dfn[y]) swap(x, y); 
    Tr.update_add(1, dfn[x], dfn[y], 1, n, d); 
    return; 
}

void Inspt(int x, int v, vector <Option> &Os)
{
    // find y
    int y = x; 
    while(y)
    {
        int idx = Tr.query_Minw(1, dfn[top[y]], dfn[y], 1, n); 
        if(idx != -1) {y = idx; break; }
        else y = fa[top[y]]; 
    }
    // printf("y = %d\n", y); 
    if(!y) 
    {
        Tr.insordel(1, 1, n, dfn[x], v); Upd(1, x, -1); 
        Os.push_back({2, x, v}); 
        return; 
    }
    else
    {
        auto [val, idx] = Tr.query(1, dfn[y], dfn[y] + siz[y] - 1, 1, n); 
        // printf("val = %d, idx = %d\n", val, idx); 
        assert(val < 1e9);
        if(v <= val) return; 
        else 
        {
            Tr.insordel(1, 1, n, dfn[idx], val, 1); Upd(1, idx, 1); 
            Os.push_back({1, idx, val});
            Tr.insordel(1, 1, n, dfn[x], v); Upd(1, x, -1); 
            Os.push_back({2, x, v});  
        }
    }
    return; 
}
i64 Ans[N];
void Solve(int root, int l, int r)
{
    // printf("Solve : root = %d, l = %d, r = %d\nS : ", root, l, r); 
    // for(auto [v, x] : Tr.T[1].S) printf("%d %d\n", x, v); 
    vector <Option> Os; 
    for(auto [x, v] : Seg[root])
    {
        // printf("Inspt : (%d, %d)\n", x, v); 
        Inspt(x, v, Os); 
    }
    if(l == r)
    {
        // printf("l = %d\nS : ", l); 
        
        Ans[l] = Tr.T[1].sum;
    }
    else 
    {
        int mid = (l + r) >> 1; 
        Solve(root << 1, l, mid), Solve(root << 1 | 1, mid + 1, r); 
    }
    // printf("Start Back\n"); 
    for(int i = (int)Os.size() - 1; i >= 0; i--) 
    {
        auto [opt, x, d] = Os[i]; 
        if(opt == 1) Tr.insordel(1, 1, n, dfn[x], d), Upd(1, x, -1); //, printf("Backadd : (%d, %d)\n", x, d); 
        else Tr.insordel(1, 1, n, dfn[x], d, 1), Upd(1, x, 1); //, printf("Backdel : (%d, %d)\n", x, d); 
    }
    Os.clear(); Os.shrink_to_fit(); 
    return; 
}

pii Pts[N]; int lf[N], rg[N]; 

signed main(void)
{
    scanf("%d", &n); int Test; 
    scanf("%d%d%d", &n, &k, &Test); 
    for(int i = 2; i <= n; i++) 
    {
        int f; scanf("%d", &f); g[f].emplace_back(i); 
    }
    dfs1(1, 0), dfs2(1, 1); Tr.build(1, 1, n); 
    // for(int i = 1; i <= n; i++) printf("dfn[%d] = %d, siz[%d] = %d, dep[%d] = %d\n", i, dfn[i], i, siz[i], i, dep[i]); 
    for(int i = 1; i <= k; i++)
    {
        int x, v; scanf("%d%d", &x, &v); Pts[i] = {x, v}; lf[i] = 0, rg[i] = Test; 
    }
    for(int i = 1; i <= Test; i++)
    {
        int opt; scanf("%d", &opt); 
        if(opt == 1)
        {
            int x, v; scanf("%d%d", &x, &v); Pts[++k] = {x, v}; lf[k] = i, rg[k] = Test; 
        }
        else 
        {
            int x; scanf("%d", &x); rg[x] = i - 1; 
        }
    }
    for(int i = 1; i <= k; i++) 
    {
        assert(lf[i] <= rg[i]); 
        Ins(1, lf[i], rg[i], 0, Test, Pts[i].first, Pts[i].second);
    }
    Solve(1, 0, Test); 
    for(int i = 0; i <= Test; i++) printf("%lld ", Ans[i]); 
    return 0; 
}