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

#define ll long long
#define pb push_back
const int N=2e5+100;
const ll INF=1e18;
mt19937 rnd(time(0));
#define gc getchar()
#define rd read()
inline int read(){
	int x=0,f=0; char c=gc;
	for(;c<'0'||c>'9';c=gc) f|=(c=='-');
	for(;c>='0'&&c<='9';c=gc) x=(x<<1)+(x<<3)+(c^48);
	return f?-x:x;
}

int n,m,fa[N];
vector<int> G[N];

ll f[N],a[N],b[N],val[N]; int rt[N];
struct FHQ{
	#define lc t[id].ls
	#define rc t[id].rs
	struct TREE{ int ls,rs,rid; ll sum,mn; }t[N];
	void psu(int id){ t[id].sum=t[lc].sum+b[id]+t[rc].sum,t[id].mn=min({t[lc].mn,t[lc].sum+f[id],t[lc].sum+b[id]+t[rc].mn}); }
	void spl(int id,int &x,int &y,ll v,int o){
		if(!id) return x=y=0,void();
		if(f[id]>v||(f[id]==v&&id>o)) x=id,spl(rc,rc,y,v,o),psu(x);
		else y=id,spl(lc,x,lc,v,o),psu(y);
	}
	int mer(int x,int y){
		if(!x||!y) return x^y;
		if(t[x].rid<t[y].rid) return t[x].rs=mer(t[x].rs,y),psu(x),x;
		else return t[y].ls=mer(x,t[y].ls),psu(y),y;
	}
	ll bry(int id,ll v){
		if(!id) return v;
		if(t[lc].mn<v) return bry(lc,v);
		else if(t[lc].sum+f[id]<v) return v-t[lc].sum;
		else return bry(rc,v-t[lc].sum-b[id]);
	}
	void ins(int u,int v){ int x,y; spl(rt[u],x,y,f[v],v),t[v].mn=f[v],t[v].sum=b[v],rt[u]=mer(x,mer(v,y)); }
	void era(int u,int v){ int x,y,z; spl(rt[u],x,z,f[v],v),spl(x,x,y,f[v],v+1),rt[u]=mer(x,z); }
	#undef lc
	#undef rc
}T;

struct SEG{
	ll div,v0,v1;
	ll get(int x){ return x<div?v0:v1; }
	SEG operator*(const SEG &x){ SEG res=x; res.v0=get(x.v0),res.v1=get(x.v1); return res; }
}sg[N];
struct SMT{
	#define lc (id<<1)
	#define rc (id<<1|1)
	#define mid (l+r>>1)
	SEG t[N<<2];
	void pushup(int id){ t[id]=t[lc]*t[rc]; }
	void chg(int id,int l,int r,int ql,const SEG &v){
		if(l==r) return t[id]=v,void();
		ql<=mid?chg(lc,l,mid,ql,v):chg(rc,mid+1,r,ql,v); pushup(id);
	}
	SEG ask(int id,int l,int r,int ql,int qr){
		if(ql<=l&&r<=qr) return t[id];
		if(qr<=mid) return ask(lc,l,mid,ql,qr);
		else if(ql>=mid+1) return ask(rc,mid+1,r,ql,qr);
		else return ask(lc,l,mid,ql,qr)*ask(rc,mid+1,r,ql,qr); 
	}
	#undef lc
	#undef rc
	#undef mid
}S;

int siz[N],son[N],top[N],btm[N],dfn[N],d_c=0;
SEG fsg(int u){
	if(!son[u]) return {0,0,a[u]};
	ll w=T.bry(rt[u],a[u]+val[u]);
	return {w,w,T.bry(rt[u],a[u]+val[u]-b[son[u]])};
}
ll ff(int u){ return S.ask(1,1,n,dfn[u],dfn[btm[top[u]]]).get(0); }
void dfs0(int u){
	siz[u]=1;
	for(int v:G[u]){
		dfs0(v),siz[u]+=siz[v];
		if(siz[v]>siz[son[u]]) son[u]=v;
	}
	for(int v:G[u]) if(v^son[u]) T.ins(u,v);
	sg[u]=fsg(u),f[u]=sg[u].get(f[son[u]]);
}
void dfs1(int u,int tp){
	dfn[u]=++d_c,btm[top[u]=tp]=u,S.chg(1,1,n,dfn[u],sg[u]);
	if(son[u]) dfs1(son[u],tp);
	for(int v:G[u]) if(v^son[u]) dfs1(v,v);
}
void chg(int x){
	for(;x;x=fa[x]){
		sg[x]=fsg(x),S.chg(1,1,n,dfn[x],sg[x]);
		x=top[x]; if(!fa[x]) return;
		T.era(fa[x],x),f[x]=ff(x),T.ins(fa[x],x);
	}
}

int main(){
	
	n=rd,m=rd;
	for(int i=2;i<=n;++i) G[fa[i]=rd].pb(i);
	for(int i=1;i<=n;++i) a[i]=rd;
	for(int i=1;i<=n;++i) b[i]=rd;
	for(int i=2;i<=n;++i) val[fa[i]]+=b[i];
	
	for(int i=1;i<=n;++i) T.t[i].rid=rnd(); T.t[0].mn=INF;
	
	dfs0(1),dfs1(1,1);
	
	for(int i=1,op,u,x,y;i<=m;++i){
		op=rd; if(op==1) u=rd,x=rd,y=rd; else x=rd,y=rd;
		if(op==1){
			a[u]=x,chg(u);
			if(!fa[u]) continue;
			val[fa[u]]+=y-b[u];
			if(u!=son[fa[u]]) T.era(fa[u],u),b[u]=y,f[u]=ff(u),T.ins(fa[u],u);
			else b[u]=y;
			chg(fa[u]);
		}
		else{ ll wx=ff(x),wy=ff(y); printf("%d\n", (wx<wy)||(wx==wy&&x<y)); }
	}
	
	return 0;
	
}