#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<string>

#define fi first
#define se second
#define mkp std::make_pair
using llu=long long unsigned;
using ll=long long;
using std::max;
using std::min;
template<class T> void cmax(T&a,T b){a=max(a,b);}
template<class T> void cmin(T&a,T b){a=min(a,b);}

const int mod=998244353;
const int NV=2e5;

namespace poly{
    const int N=1<<19;
    int rev[N],wn[N],lim,invlim;
    int ksm(int a,int p){
        int ans=1;
        while(p){
            if(p&1) ans=(llu)ans*a%mod;
            a=(llu)a*a%mod;
            p>>=1;
        }return ans;
    }void init(int len){
        for(lim=1;lim<len;lim*=2);
        invlim=mod-(mod-1)/lim;
        for(int i=1;i<lim;++i) rev[i]=rev[i/2]/2|((i&1)*lim/2);
        for(int i=1;i<lim;i*=2){
            wn[i]=1;
            const int w=ksm(3,mod/i/2);
            for(int j=1;j<i;++j) wn[i+j]=(llu)wn[i+j-1]*w%mod;
        }
    }void DFT(int*a){
        static llu t[N];
        for(int i=0;i<lim;++i) t[i]=a[rev[i]];
        for(int i=1;i<lim;i*=2)
        for(int j=0;j<lim;j+=i*2)
        for(int k=0;k<i;++k){
            const llu x=t[i+j+k]*wn[i+k]%mod;
            t[i+j+k]=t[j+k]+mod-x;
            t[j+k]+=x;
        }
        for(int i=0;i<lim;++i) a[i]=t[i]%mod;
    }inline void IDFT(int*a){
        DFT(a);
        std::reverse(a+1,a+lim);
        for(int i=0;i<lim;++i) a[i]=(llu)a[i]*invlim%mod;
    }void cpy(int*a,int*b,int n){
        memcpy(a,b,sizeof*a*n);
        memset(a+n,0,sizeof*a*(lim-n));
    }
    using POLY=std::vector<int>;
    auto mul(POLY a,POLY b){
        static int A[N],B[N];
        const int N=a.size()+b.size()-1;
        init(N);
        cpy(A,a.data(),a.size());
        cpy(B,b.data(),b.size());
        DFT(A);
        DFT(B);
        for(int i=0;i<lim;++i) A[i]=(llu)A[i]*B[i]%mod;
        IDFT(A);
        return POLY(A,A+N);
    }
    std::vector<int> li;
    auto fzc(int l,int r){
        if(l+1==r) return POLY({mod+1-li[l],li[l]});
        int mid=l+r>>1;
        return mul(fzc(l,mid),fzc(mid,r));
    }auto get(const std::vector<int>&o){
        li=o;
        return fzc(0,o.size());
    }
}

int N,Q;

namespace seg{
    struct SEGT{
        int m,a;
    } tr[NV*26];
    int ls[NV*26],rs[NV*26],cnt,rt[NV+5];
    SEGT&operator+=(SEGT&x,const SEGT&y){
        x.a=((llu)x.a*y.m+y.a)%mod;
        x.m=(llu)x.m*y.m%mod;
        return x;
    }bool nleaf(int x){return ls[x];}
    void dn(int x){
        tr[ls[x]]+=tr[x];
        tr[rs[x]]+=tr[x];
        tr[x]={1,0};
    }void upd(int x,int l,int r,int ql,int qr,SEGT z){
        if(ql<=l&&r<=qr){
            tr[x]+=z;
            //printf("updend %d[%d,%d]%d %d\n",x,l,r,tr[x].m,tr[x].a);
            return;
        }
        int mid=l+r>>1;
        if(!ls[x]) ls[x]=++cnt;
        if(!rs[x]) rs[x]=++cnt;
        dn(x);
        if(ql<=mid) upd(ls[x],l,mid,ql,qr,z);
        if(mid<qr) upd(rs[x],mid+1,r,ql,qr,z);
    }void dfs(int x,int l,int r){
        if(!x) return;
        printf("%d[%d,%d]%d %d\n",x,l,r,tr[x].m,tr[x].a);
        if(!ls[x]){
            return;
        }
        int mid=l+r>>1;
        dn(x);
        dfs(ls[x],l,mid);
        dfs(rs[x],mid+1,r);
    }
}

namespace gph{
    std::vector<std::pair<int,int> > ques[NV+5];
    std::vector<int> G[NV+5];

    int merge(std::vector<int>&rts,poly::POLY p,int deg){
        if(rts.size()==1) return rts[0];
        auto mid=std::partition(rts.begin(),rts.end(),seg::nleaf);
        if(mid==rts.begin()) ++mid;
        std::vector<int> o(rts.end()-mid);
        for(auto i=mid;i!=rts.end();++i) o[i-mid]=seg::tr[*i].a;
        rts.resize(mid-rts.begin());
        const int r=rts[0];
        if(o.size()){
            if(deg<0){ // TODO
                seg::tr[r]+=seg::SEGT{0,1};
                return r;
            }
            p=poly::mul(p,poly::get(o));
            p.resize(deg+1);
        }
        const int rss=rts.size();
        if(deg>rss){
            p.erase(p.begin(),p.begin()+(deg-rss));
            deg=rss;
        }
        if(rts.size()==1){
            seg::tr[r]+=seg::SEGT{(p[deg]-p[deg-1]+mod)%mod,
                (mod+1-p[deg])%mod};
            return r;
        }
        for(int x:rts) seg::dn(x);
        auto sons=rts;
        for(int&x:sons) x=seg::ls[x];
        seg::ls[r]=merge(sons,p,deg);
        sons=rts;
        for(int&x:sons) x=seg::rs[x];
        seg::rs[r]=merge(sons,p,deg);
        return r;
    }int build(int x){
        ques[x].emplace_back(Q+1,0);
        int u=++seg::cnt;
        //printf("build %d\n",x);
        for(int i=0;i+1<(int)ques[x].size();++i){
            seg::upd(u,0,Q,ques[x][i].fi,ques[x][i+1].fi-1,
                    seg::SEGT{1,ques[x][i].se});
            //printf("%d,%d => %d\n",ques[x][i].fi,ques[x][i+1].fi-1, ques[x][i].se);
        }
        return u;
    }void dfs(int x){
        std::vector<int> rts;
        rts.push_back(build(x));
        //printf("raw %d=>%d\n",x,rts[0]);
        //seg::dfs(rts[0],0,Q);
        for(int t:G[x]){
            dfs(t);
            rts.push_back(seg::rt[t]);
        }
        int pos=rts.size()/2;
        poly::POLY tmp(pos+1,1);
        seg::rt[x]=merge(rts,tmp,pos);
        //printf("print %d=>%d\n",x,seg::rt[x]);
        //seg::dfs(seg::rt[x],0,Q);
    }
}

namespace xm{
    void print(int x,int l,int r){
        if(l==r){
            printf("%d\n",seg::tr[x].a);
        }else{
            int mid=l+r>>1;
            seg::dn(x);
            print(seg::ls[x],l,mid);
            print(seg::rs[x],mid+1,r);
        }
    }
    void _(){
        scanf("%d%d",&N,&Q);
        for(int i=2,p;i<=N;++i){
            scanf("%d",&p);
            gph::G[p].push_back(i);
        }for(int i=1;i<=N;++i){
            int x;
            scanf("%d",&x);
            gph::ques[i].emplace_back(0,x);
        }for(int i=1;i<=Q;++i){
            int x,y;
            scanf("%d%d",&x,&y);
            gph::ques[x].emplace_back(i,y);
        }
        gph::dfs(1);
        print(seg::rt[1],0,Q);
    }
}

int main(){
    xm::_();
    return 0;
}