# include <bits/stdc++.h>

const int N=300010,INF=0x3f3f3f3f,mod=998244353;


namespace PolyNomial{
# define ull unsigned long long
# define ll long long
# define mo MOD
# define poly std::vector <int>
	const int FFTN=1<<18,MOD=998244353;
	int w[FFTN+10],W[FFTN+10],rev[FFTN+10];
	int pinv[30];
	inline void qadd(int &x,int v){
		x+=v,((x>=mo)&&(x-=mo));
		return;
	}
	inline int qpow(int d,int p){
		int ans=1;
		for(;p;p>>=1,d=1ll*d*d%mo) (p&1)&&(ans=1ll*ans*d%mo);
		return ans;
	}
	inline void initW(void){
		W[0]=1,W[1]=qpow(3,(mo-1)/FFTN);
		for(int i=2;i<=FFTN;++i) W[i]=1ll*W[i-1]*W[1]%mo;
		pinv[0]=1; for(int i=1;i<=25;++i) pinv[i]=qpow((1<<i),mod-2);
		return;
	}
	inline int initRev(int len){
		int n=1;
		while(n<=len) n<<=1;
		for(int i=0;i<n;++i) rev[i]=(rev[i>>1]>>1)|((i&1)?(n>>1):0);
		return n;
	}
	
	int A[FFTN+10],B[FFTN+10],C[FFTN+10];
	ull va[FFTN+10];
	
	inline void NTT(int *F,int len){
		for(int i=0;i<len;++i) va[rev[i]]=F[i];
		
		for(int l=1;l<len;l<<=1){ // 2 * l -> 1 * 2l
			int siz=FFTN/(l<<1);
			for(int i=0,j=0;i<l;++i,j+=siz) w[i]=W[j]; // omega_{n}^{i} = W_j
			for(int s=0;s<len;s+=(l<<1))
				for(int j=0;j<l;++j){
					int v=va[s+j+l]*w[j]%mo;
					va[s+j+l]=va[s+j]+mo-v,va[s+j]+=v;
				}
			if(l==(1<<15)) for(int i=0;i<len;++i) va[i]%=mo;
		}
		for(int i=0;i<len;++i) F[i]=va[i]%mo;
		return;
	}
	inline void INTT(int *F,int len){
		for(int i=0;i<len;++i) va[rev[i]]=F[i];
		
		for(int l=1;l<len;l<<=1){ // 2 * l -> 1 * 2l
			int siz=FFTN/(l<<1);
			for(int i=0,j=FFTN;i<l;++i,j-=siz) w[i]=W[j]; // omega_{n}^{i} = W_j
			for(int s=0;s<len;s+=(l<<1))
				for(int j=0;j<l;++j){
					int v=va[s+j+l]*w[j]%mo;
					va[s+j+l]=va[s+j]+mo-v,va[s+j]+=v;
				}
			if(l==(1<<15)) for(int i=0;i<len;++i) va[i]%=mo;
		}
		int invn=pinv[std::__lg(len)];
		for(int i=0;i<len;++i) F[i]=va[i]*invn%mo;
		return;
	}
	inline poly Mul(const poly &a,int k){
		int dea=a.size();
		poly ans(dea+1);
		for(int i=0;i<=dea;++i) ans[i]=1ll*a[i]*k%mo;
		return ans;
	}
	inline poly Mul(const poly &a,const poly &b){
		int dea=a.size()-1,deb=b.size()-1;
		assert(dea>=0&&deb>=0);
		poly ans(dea+deb+1);
		int blen=initRev(dea+deb);
		for(int i=0;i<blen;++i) A[i]=((i<=dea)?a[i]:0),B[i]=((i<=deb)?b[i]:0);
		NTT(A,blen),NTT(B,blen);
		for(int i=0;i<blen;++i) A[i]=1ll*A[i]*B[i]%mo;
		INTT(A,blen);
		for(int i=0;i<=dea+deb;++i) ans[i]=A[i];
		return ans;
	}
# undef ull
# undef ll
# undef mo
}
inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-')f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

std::vector <int> G[N];

int w[N];
int n,q;
int idx[N];
int f[N];
int L[N];

inline int lc(int x){return x<<1;}
inline int rc(int x){return x<<1|1;}

inline int adc(int a,int b){return (a+b>=mod)?(a+b-mod):(a+b);}
inline int dec(int a,int b){return (a<b)?(a-b+mod):(a-b);}
inline int mul(int a,int b){return 1ll*a*b%mod;}
inline void add(int &a,int b){a=adc(a,b);}
inline void del(int &a,int b){a=dec(a,b);}

namespace SEG{
int n;
poly F[N<<2];
int len[N<<2];
std::vector <int> ws[N<<2];

int tic[2*N],tc,qc;

inline void clear(int k,int l,int r){
	std::vector <int> ().swap(ws[k]),std::vector <int> ().swap(F[k]),len[k]=0;
	if(l==r) return;
	int mid=(l+r)>>1;
	clear(lc(k),l,mid),clear(rc(k),mid+1,r);
	return;
}

inline poly multi(poly &p,int l,int r){
	if(l==r) return (poly){dec(1,p[l]),p[l]};
	int mid=(l+r)>>1;
	return PolyNomial::Mul(multi(p,l,mid),multi(p,mid+1,r));
}

inline void modify(int k,int l,int r,int L,int R,int w){
	if(L<=l&&r<=R) return ws[k].push_back(w),void();
	int mid=(l+r)>>1;
	if(L<=mid) modify(lc(k),l,mid,L,R,w);
	if(mid<R) modify(rc(k),mid+1,r,L,R,w);
	return;
}

inline void calc(int k,int l,int r){
	if(ws[k].size()) F[k]=multi(ws[k],0,ws[k].size()-1);
	if(l==r) return len[k]=1,void();
	int mid=(l+r)>>1;
	calc(lc(k),l,mid),calc(rc(k),mid+1,r),len[k]=len[lc(k)]+ws[lc(k)].size();
	return;
}

int ans[N],fm[N];

inline void solve(int k,int l,int r,int d,poly A,int cur){ // F'[x] = F[x+d]
	poly B=(F[k].size())?PolyNomial::Mul(A,F[k]):A,C=poly(len[k]);
	for(int i=0;i<(int)B.size();++i){
		if(i+d<=n/2-len[k]) add(cur,B[i]);
		else if(i+d<=n/2) C[i+d-1-(n/2-len[k])]=B[i];
		else break;
	}
	if(l==r) return ans[l]=cur,fm[l]=C[0],void();
	int mid=(l+r)>>1;
	solve(lc(k),l,mid,(n/2-len[k])+1,C,cur);
	solve(rc(k),mid+1,r,(n/2-len[k])+1,C,cur);
	return;
}

int pl[N*2],pr[N*2],pw[N*2];

inline void ins(int l,int r,int w){
	++tc,tic[tc]=pl[tc]=l,pr[tc]=r,pw[tc]=w;
	return;
}
inline void gclear(void){
	clear(1,1,tc),tc=0;
	return;
}
inline void gsolve(int _n){
	n=_n,qc=tc;
	std::sort(tic+1,tic+1+tc),tc=std::unique(tic+1,tic+tc+1)-(tic+1),tic[++tc]=q+1;
	for(int i=1;i<=qc;++i){
		int l=std::lower_bound(tic+1,tic+1+tc,pl[i])-tic;
		int r=std::lower_bound(tic+1,tic+1+tc,pr[i])-tic-1;
		modify(1,1,tc-1,l,r,pw[i]);
	}
	calc(1,1,tc-1);
	solve(1,1,tc-1,0,{1},0);
	return;
}
}

int dep[N],siz[N],son[N];
int pos[N];

void predfs(int x){
	dep[x]=dep[f[x]]+1,siz[x]=1; 
	for(auto y:G[x]){
		predfs(y),siz[x]+=siz[y]; if(siz[son[x]]<siz[y]) son[x]=y;
	}
	return;
}

namespace SGT{
struct Node{
	int k,b; // x -> k*x + b
	Node(int _k=1,int _b=0): k(_k),b(_b){}
	inline Node operator + (const Node &rhs) const{ // k1(k2x+b2) + b1
		return Node(mul(k,rhs.k),adc(mul(k,rhs.b),b));
	}
}tr[N<<2];

void build(int k,int l,int r){
	tr[k]=Node();
	if(l==r) return;
	int mid=(l+r)>>1;
	return build(lc(k),l,mid),build(rc(k),mid+1,r);
}
void modify(int k,int l,int r,int x,Node w){
	if(l==r) return tr[k]=w,void();
	int mid=(l+r)>>1;
	if(x<=mid) modify(lc(k),l,mid,x,w); else modify(rc(k),mid+1,r,x,w);
	tr[k]=tr[lc(k)]+tr[rc(k)];
	return;
}
}

std::vector <std::array <int,2> > S[N],T[N]; // (a,b) in S[x]: tick a, val to b

void ddp(int x){
	std::vector <std::array <int,4> > W;
	std::vector <int> po(1);
	
	int len=0,u=x;
	while(u) pos[u]=++len,po.push_back(u),u=son[u];
	if(len==1) return T[x].swap(S[x]),void();
	
	for(int i=0,u=po[len];i<(int)T[u].size();++i) // bottom
		W.push_back({T[u][i][0],len,dec(1,T[u][i][1]),0});
	
	for(int idx=len-1;idx;--idx){
		u=po[idx];

		for(auto v:G[u]) if(son[u]!=v) ddp(v);
		for(auto v:G[u]) if(son[u]!=v){
			for(int i=0;i<(int)S[v].size();++i){
				SEG::ins(S[v][i][0],(i==(int)S[v].size()-1)?q+1:S[v][i+1][0],S[v][i][1]);
			}
		}
				
		for(int i=0;i<(int)T[u].size();++i){
			SEG::ins(T[u][i][0],(i==(int)T[u].size()-1)?q+1:T[u][i+1][0],T[u][i][1]);
		}
		SEG::gsolve(G[u].size()+1);
		for(int i=1;i<SEG::tc;++i){
			W.push_back({SEG::tic[i],idx,SEG::ans[i],SEG::fm[i]});
		}
		SEG::gclear();
	}
	
	std::sort(W.begin(),W.end());
	int wlen=(int)W.size();
	SGT::build(1,1,len); 
	
	for(int l=0,r;l<wlen;l=r+1){
		r=l; while(r<wlen&&W[r][0]==W[l][0]) ++r; --r;
		for(int i=l;i<=r;++i) SGT::modify(1,1,len,W[i][1],SGT::Node(W[i][3],W[i][2]));		
		S[x].push_back({W[r][0],dec(1,SGT::tr[1].b)});
	}
	
	return;
}

int main(void){
	PolyNomial::initW();
	n=read(),q=read();
	
	for(int i=2;i<=n;++i) f[i]=read(),G[f[i]].push_back(i);
	for(int i=1;i<=n;++i) w[i]=read(),T[i].push_back({0,w[i]});
		
	for(int i=1;i<=q;++i){
		int x=read(),y=read(); T[x].push_back({i,y});
	}
	
	predfs(1);
	ddp(1);
	
	for(auto v:S[1]) printf("%d\n",v[1]);
	
	return 0;
}