#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
const int maxn=1e5+10;
const int inf=0x3f3f3f3f;
#define val first
#define id second

pii min(pii X,pii Y){
    if(X.val<Y.val) return X;
    else return Y;
}

inline int read(){
    int x=0,w=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c<='9'&&c>='0'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*w;
}

int n,k,m;
vector<int> E[maxn];
int fa[maxn],dep[maxn],siz[maxn],son[maxn];
int dfn[maxn],iddfn[maxn],dfncnt,top[maxn];
void dfs1(int u,int f,int d){
    fa[u]=f,dep[u]=d,siz[u]=1;
    int maxson=-1;
    for(int v:E[u]){
        if(v==f) continue;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(siz[v]>maxson) maxson=siz[v],son[u]=v;
    }
}
void dfs2(int u,int t){
    dfn[u]=++dfncnt,iddfn[dfncnt]=u,top[u]=t;
    if(!son[u]) return;
    dfs2(son[u],t);
    for(int v:E[u]){
        if(v==fa[u]||v==son[u]) continue;
        dfs2(v,v);
    }
}

int p[maxn<<1],v[maxn<<1];
int lp[maxn<<1],rp[maxn<<1];

//维护节点子树剩余位置个数
//区间加，区间最小值
struct SegmentTree_CNT{
#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
    ll cnt[maxn<<2];
    pii mn[maxn<<2];
    ll tag[maxn<<2];
    inline void push_up(int rt){
        cnt[rt]=cnt[rt<<1]+cnt[rt<<1|1];
        mn[rt]=min(mn[rt<<1],mn[rt<<1|1]);
    }
    inline void push_down(int rt,int l,int r){
        if(tag[rt]){
            // cerr<<"PUSHDOWN rt:"<<rt<<" ["<<l<<","<<r<<"]"<<" tag:"<<tag[rt]<<endl;
            cnt[rt<<1]+=1ll*tag[rt]*(mid-l+1);
            mn[rt<<1].val+=tag[rt];
            tag[rt<<1]+=tag[rt];
            cnt[rt<<1|1]+=1ll*tag[rt]*(r-mid);
            mn[rt<<1|1].val+=tag[rt];
            tag[rt<<1|1]+=tag[rt];
            // cerr<<"lcnt:"<<cnt[rt<<1]<<" ltag:"<<tag[rt<<1]<<" rcnt:"<<cnt[rt<<1|1]<<" rtag:"<<tag[rt<<1|1]<<endl;
            tag[rt]=0;
        }
    }
    void build(int rt,int l,int r){
        if(l==r){
            cnt[rt]=siz[l];
            mn[rt]=make_pair(siz[iddfn[l]],l);
            tag[rt]=0;
            return;
        }
        push_down(rt,l,r);
        build(lson),build(rson);
        push_up(rt);
    }
    void update(int rt,int l,int r,int pl,int pr,int k){
        if(pl<=l&&r<=pr){
            cnt[rt]+=1ll*k*(r-l+1);
            mn[rt].val+=k;
            tag[rt]+=k;
            return;
        }
        push_down(rt,l,r);
        if(pl<=mid) update(lson,pl,pr,k);
        if(pr>mid) update(rson,pl,pr,k);
        push_up(rt);
    }
    pii query(int rt,int l,int r,int pl,int pr){
        if(pl<=l&&r<=pr) return mn[rt];
        push_down(rt,l,r);
        if(pr<=mid) return query(lson,pl,pr);
        else if(pl>mid) return query(rson,pl,pr);
        else return min(query(lson,pl,pr),query(rson,pl,pr)); 
    }
    void output(int rt,int l,int r){
        // cerr<<"rt:"<<rt<<" ["<<l<<","<<r<<"] mncnt:"<<mn[rt].val<<" mnid:"<<iddfn[mn[rt].id]<<endl;
        if(l==r) return;
        push_down(rt,l,r);
        output(lson),output(rson);
    }
#undef mid
#undef lson
#undef rson
}SC;

inline void update_SC(int u,int v,int k){
    while(top[u]!=top[v]){
        if(dep[top[u]]>dep[top[v]]) swap(u,v);
        // cerr<<"USC ["<<dfn[top[v]]<<","<<dfn[v]<<"]"<<endl;
        SC.update(1,1,n,dfn[top[v]],dfn[v],k);
        v=fa[top[v]];
    }
    if(dep[u]>dep[v]) swap(u,v);
    // cerr<<"USC ["<<dfn[top[v]]<<","<<dfn[v]<<"]"<<endl;
    SC.update(1,1,n,dfn[u],dfn[v],k);
}
inline pii query_SC(int u,int v){
    pii res=make_pair(inf,inf);
    while(top[u]!=top[v]){
        if(dep[top[u]]>dep[top[v]]) swap(u,v);
        // cerr<<"QSC ["<<dfn[top[v]]<<","<<dfn[v]<<"]"<<endl;
        res=min(SC.query(1,1,n,dfn[top[v]],dfn[v]),res);
        v=fa[top[v]];
    }
    if(dep[u]>dep[v]) swap(u,v);
    // cerr<<"QSC ["<<dfn[top[v]]<<","<<dfn[v]<<"]"<<endl;
    res=min(SC.query(1,1,n,dfn[u],dfn[v]),res);
    res.id=iddfn[res.id];
    return res;
}

ll sum;
//维护节点上最小值
//插入修改 multiset
struct SegmentTree_VAL{
#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
    pii mn[maxn<<2];
    multiset<int> MS[maxn<<2];
    inline void push_up(int rt){
        mn[rt]=min(mn[rt<<1],mn[rt<<1|1]);
    }
    inline void build(int rt,int l,int r){
        if(l==r){
            mn[rt]=make_pair(inf,l);
            return;
        }
        build(lson),build(rson);
        push_up(rt);
    }
    void insert(int rt,int l,int r,int p,int k){
        if(l==r){
            sum+=k;
            MS[rt].insert(k);
            mn[rt].val=*MS[rt].begin();
            return;
        }
        if(p<=mid) insert(lson,p,k);
        else insert(rson,p,k);
        push_up(rt);
    }
    void erase(int rt,int l,int r,int p,int k){
        if(l==r){
            sum-=k;
            auto it=MS[rt].find(k);
            if(it==MS[rt].end()) cerr<<-1<<endl;
            MS[rt].erase(it);
            if(MS[rt].size()) mn[rt].val=*MS[rt].begin();
            else mn[rt].val=inf;
            return;
        }
        if(p<=mid) erase(lson,p,k);
        else erase(rson,p,k);
        push_up(rt);
    }
    pii query(int rt,int l,int r,int pl,int pr){
        if(pl<=l&&r<=pr) return mn[rt];
        if(pr<=mid) return query(lson,pl,pr);
        else if(pl>mid) return query(rson,pl,pr);
        else return min(query(lson,pl,pr),query(rson,pl,pr));
    }
#undef mid
#undef lson
#undef rson
}SV;

ll ans[maxn];

struct SegmentTree_DAC{
#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
    struct Data{
        bool type;
        int erap,erav;
        int insp,insv;
        Data()=default;
        Data(bool type_,int erap_,int erav_,int insp_,int insv_):type(type_),erap(erap_),erav(erav_),insp(insp_),insv(insv_){}
    };
    vector<int> V[maxn<<3];
    vector<Data> Q[maxn<<3]; 
    void update(int rt,int l,int r,int pl,int pr,int k){
        if(pl<=l&&r<=pr){
            V[rt].push_back(k);
            return;
        }
        if(pl<=mid) update(lson,pl,pr,k);
        if(pr>mid) update(rson,pl,pr,k);
    }
    void dfs(int rt,int l,int r){
        for(int i=0;i<V[rt].size();++i){
            int x=V[rt][i];
            pii mn_cnt=query_SC(1,p[x]);
            // cerr<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
            // SC.output(1,1,n);
            // cerr<<"rt:"<<rt<<" ["<<l<<","<<r<<"]"<<" x:"<<x<<" mncnt:"<<mn_cnt.val<<" mnid:"<<mn_cnt.id<<endl;
            if(mn_cnt.val){
                update_SC(1,p[x],-1);
                SV.insert(1,1,n,dfn[p[x]],v[x]);
                // cerr<<"INS ("<<p[x]<<","<<v[x]<<")"<<endl;
                Q[rt].push_back(Data(1,0,0,p[x],v[x]));
            }
            else{
                int u=mn_cnt.id;
                pii mn_val=SV.query(1,1,n,dfn[u],dfn[u]+siz[u]-1);
                mn_val.id=iddfn[mn_val.id];
                if(mn_val.val>=v[x]) continue;
                update_SC(1,mn_val.id,1);
                update_SC(1,p[x],-1);
                SV.erase(1,1,n,dfn[mn_val.id],mn_val.val);
                SV.insert(1,1,n,dfn[p[x]],v[x]);
                // cerr<<"ERA ("<<mn_val.id<<","<<mn_val.val<<")"<<endl;
                // cerr<<"INS ("<<p[x]<<","<<v[x]<<")"<<endl;
                Q[rt].push_back(Data(0,mn_val.id,mn_val.val,p[x],v[x]));
            }
        }
        if(l==r) ans[l]=sum;
        else dfs(lson),dfs(rson);
        for(int i=Q[rt].size()-1;i>=0;--i){
            Data now=Q[rt][i];
            if(now.type){
                update_SC(1,now.insp,1);
                SV.erase(1,1,n,dfn[now.insp],now.insv);
            }
            else{
                update_SC(1,now.erap,-1);
                update_SC(1,now.insp,1);
                SV.insert(1,1,n,dfn[now.erap],now.erav);
                SV.erase(1,1,n,dfn[now.insp],now.insv);
            }
        }
    }
#undef mid
#undef lson
#undef rson
}SD;


int main(){
    read(),n=read(),k=read(),m=read();
    for(int v=2;v<=n;++v){
        int u=read();
        E[u].push_back(v);
    }
    dfs1(1,0,0);
    dfs2(1,1);
    SC.build(1,1,n);
    SV.build(1,1,n);
    // SC.output(1,1,n);
    for(int i=1;i<=k;++i){
        p[i]=read(),v[i]=read();
        lp[i]=1;
    }
    for(int i=2;i<=m+1;++i){
        int opt=read();
        if(opt==1){
            ++k;
            p[k]=read(),v[k]=read();
            lp[k]=i;
        }
        else{
            int x=read();
            rp[x]=i-1;
        }
    }
    for(int i=1;i<=k;++i){
        if(!rp[i]) rp[i]=m+1;
        SD.update(1,1,m+1,lp[i],rp[i],i);
    }
    SD.dfs(1,1,m+1);
    for(int i=1;i<=m+1;++i) printf("%lld ",ans[i]);
    printf("\n");
    return 0;
}