#include<bits/stdc++.h>
#define pb push_back
#define ll long long
using namespace std;
const int N=2e5+5;
const ll INF=1e18;
namespace IO{
    static int len=0;
    static char ibuf[(1<<20)+5],*iS,*iT,out[(1<<20)+1];
    #define gc() (iS==iT?iT=(iS=ibuf)+fread(ibuf,1,1<<20,stdin),(iS==iT?EOF:*iS++):*iS++)
    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*10+(c^48);
        return f?-x:x;
    }
    inline void flush(){fwrite(out,1,len,stdout);len=0;}
    inline void pc(char ch){out[len++]=ch;if(len>=1000000) flush();}
    inline void write(int x){
        // static int st[20],top=0;
        // if(x<0) pc('-'),x=-x;
        // do{st[++top]=x%10,x/=10;}while(x);
        // while(top) pc(st[top--]+'0');
        pc(x+'0'),pc('\n');
    }
}using namespace IO;
mt19937 rng(time(0));
int Tim,n,q,f[N];
int a[N],b[N],rt[N];
ll dp[N],sumb[N];
vector<int>G[N];
struct Node{int lc,rc,p;ll s,mn;}t[N];
#define k1 t[k].lc
#define k2 t[k].rc
inline void up(int k){
	t[k].s=t[k1].s+b[k]+t[k2].s,t[k].mn=min({t[k1].mn,t[k1].s+dp[k],t[k1].s+b[k]+t[k2].mn});
}
inline void split(int k,ll val,int id,int &x,int &y){
	if(!k) return x=y=0,void();
	if(dp[k]>val||(dp[k]==val&&k>id)) x=k,split(k2,val,id,t[x].rc,y),up(x);
	else y=k,split(k1,val,id,x,t[y].lc),up(y);
}
inline int mer(int x,int y){
	if(!x||!y) return x|y;
	if(t[x].p<t[y].p) return t[x].rc=mer(t[x].rc,y),up(x),x;
	else return t[y].lc=mer(x,t[y].lc),up(y),y;
}
inline ll ask(int k,ll val){
	if(!k) return val;
	if(t[k1].mn<val) return ask(k1,val);
	if(t[k1].s+dp[k]<val) return val-t[k1].s;
	return ask(k2,val-t[k1].s-b[k]);
}
int x,y,z;
inline void ins(int u,int v){
	split(rt[u],dp[v],v,x,y),t[v].mn=dp[v],t[v].s=b[v],rt[u]=mer(x,mer(v,y));
}
inline void erase(int u,int v){
	split(rt[u],dp[v],v,x,y),split(y,dp[v],v-1,y,z),rt[u]=mer(x,z);
}
#undef k1
#undef k2
struct info{
	ll k,a,b;
	inline ll w(ll x){return x<k?a:b;}
	inline friend info operator+(info A,info B){return (info){A.k,B.w(A.a),B.w(A.b)};}
}A[N];
int sz[N],rev[N],son[N],top[N],lst[N],dfn[N],dn;
namespace ST{
	const int M=(N<<2)+5;
	info t[(M<<2)+5];
	inline void upd(int x){
		for(x+=M,t[x]=A[rev[x-M]];x>>=1;) t[x]=t[x<<1|1]+t[x<<1];
	}
	inline info ask(int l,int r){
		bool cl=1,cr=1;
		info lv,rv;
		for(l+=M-1,r+=M+1;l^r^1;l>>=1,r>>=1){
			if(~l&1) cl?cl=0,lv=t[l^1]:lv=t[l^1]+lv;
			if(r&1) cr?cr=0,rv=t[r^1]:rv=rv+t[r^1];
		}
		return cl?rv:(cr?lv:rv+lv);
	}
}
inline info qry(int x){
	if(!son[x]) return {0,0,a[x]};
	ll w=ask(rt[x],a[x]+sumb[x]);
	return {w,w,ask(rt[x],a[x]+sumb[x]-b[son[x]])};
}
inline void dfs1(int x){
	sz[x]=1;
	for(auto v:G[x])
		dfs1(v),sz[x]+=sz[v],son[x]=sz[v]>sz[son[x]]?v:son[x];
	for(auto v:G[x]) if(v!=son[x]) ins(x,v);
	A[x]=qry(x),dp[x]=A[x].w(dp[son[x]]);
}
inline void dfs2(int x,int tp){
	dfn[x]=++dn,rev[dn]=x,top[x]=tp,ST::upd(dfn[x]);
	if(son[x]) dfs2(son[x],tp),lst[x]=lst[son[x]];
	else lst[x]=x;
	for(auto v:G[x]) if(v!=son[x]) dfs2(v,v);
}
inline ll ask(int x){return ST::ask(dfn[x],dfn[lst[x]]).w(0);}
inline void upd(int x){
	for(;x;x=f[x]){
		A[x]=qry(x),ST::upd(dfn[x]),x=top[x];
		if(x!=1) erase(f[x],x),dp[x]=ask(x),ins(f[x],x);
	}
}
signed main(){
	n=read(),q=read(),t[0].mn=INF;
	for(int i=2;i<=n;++i) f[i]=read(),G[f[i]].pb(i);
	for(int i=1;i<=n;++i) a[i]=read(),t[i].p=rng();
	for(int i=1;i<=n;++i) b[i]=read();
	for(int i=2;i<=n;++i) sumb[f[i]]+=b[i];
	dfs1(1),dfs2(1,1);
	for(int opt,u,x,y,i=1;i<=q;++i){
		opt=read();
		if(opt==1){
			u=read(),x=read(),y=read(),a[u]=x,upd(u);
			if(u>1){
				sumb[f[u]]+=y-b[u];
				if(u!=son[f[u]]) erase(f[u],u),b[u]=y,dp[u]=ask(u),ins(f[u],u);
				else b[u]=y;
				upd(f[u]);
			}
		}
		else{
			x=read(),y=read();ll vx=ask(x),vy=ask(y);
			write(vx<vy||(vx==vy&&x<y));
		}
	}
	flush();
}