#include<bits/stdc++.h>
#define N 200010
#define ll long long
#define pc putchar
#define inf (1ll<<60)
#define lc k<<1
#define rc k<<1|1
#define pii pair<int,int>
#define fi first
#define se second
#define For(i,a,b) for(register int i=a;i<=b;i++)
using namespace std;
int n,m,a[N],b[N],fa[N],top[N];
int sz[N],son[N],seg[N];
int ch[N][2],rt[N],p[N];
ll f[N],sum[N],val[N],mn[N];
vector<int> go[N];
mt19937 rnd(20061130);
struct ele
{
    ll n0,v0,v1;
    inline ll get(ll nw)
        {return nw<n0?v0:v1;}
    inline ele operator +(const ele b)
    {
        ele res;res.v1=get(b.v1);
        res.n0=b.n0,res.v0=get(b.v0);
        return res;
    }
}v[N],tr[N<<2];
inline int read()
{
    register int x=0,c=getchar();
    while(!isdigit(c)) c=getchar();
    while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
    return x;
}

inline void pushup(int x)
{
    val[x]=val[ch[x][0]]+b[x]+val[ch[x][1]];
    mn[x]=min(mn[ch[x][0]],val[ch[x][0]]+f[x]);
    mn[x]=min(mn[x],val[ch[x][0]]+b[x]+mn[ch[x][1]]);
    return;
}

inline int merge(int x,int y)
{
    if(!x || !y) return x+y;
    if(p[x] < p[y])
    {
        ch[x][1]=merge(ch[x][1],y);
        pushup(x);return x;
    }ch[y][0]=merge(x,ch[y][0]);
    pushup(y);return y;
}

inline pii divide(int x,ll k,int id)
{
    if(!x) return pii(0,0);
    if(f[x] > k || f[x] == k && x > id)
    {
        pii a=divide(ch[x][1],k,id);
        ch[x][1]=a.fi,pushup(x);
        return pii(x,a.se);
    }pii a=divide(ch[x][0],k,id);
    ch[x][0]=a.se,pushup(x);
    return pii(a.fi,x);
}

inline ll binary(int x,ll k)
{
    if(!x) return k;
    if(k > mn[ch[x][0]])
        return binary(ch[x][0],k);
    if(k > val[ch[x][0]]+f[x])
        return k-val[ch[x][0]];
    return binary(ch[x][1],k-val[ch[x][0]]-b[x]);
}

inline void insert(int &rt,int x)
{
    pii a=divide(rt,f[x],x);
    rt=merge(a.fi,merge(x,a.se));
    return;
}

inline void erase(int &rt,int x)
{
    pii a=divide(rt,f[x],x);
    pii b=divide(a.se,f[x],x-1);
    rt=merge(a.fi,b.se);
    return;
}

inline void calc(int t,int x)
{
    if(!x) {v[t].n0=inf,v[t].v0=a[t];return;}
    ll nw=binary(rt[t],sum[t]+a[t]);
    v[t].n0=v[t].v0=nw;
    v[t].v1=binary(rt[t],sum[t]+a[t]-b[x]);
    return;
}

inline void modify(int k,int l,int r,int pos,ele nw)
{
    if(l == r) {tr[k]=nw;return;}
    int mid=l+r>>1;
    if(pos <= mid) modify(lc,l,mid,pos,nw);
    else modify(rc,mid+1,r,pos,nw);
    return void(tr[k]=tr[lc]+tr[rc]);
}

inline ele query(int k,int l,int r,int pos)
{
    if(l >= pos) return tr[k];
    int mid=l+r>>1;
    if(pos > mid) return query(rc,mid+1,r,pos);
    return query(lc,l,mid,pos)+query(rc,mid+1,r,pos);
}

inline void dfs1(int x)
{
    sz[x]=1;
    for(int to:go[x])
    {
        dfs1(to),sum[x]+=b[to],sz[x]+=sz[to];
        if(sz[to] > sz[son[x]]) son[x]=to;
    }
    for(int to:go[x]) if(to^son[x])
    {
        val[to]=b[to],p[to]=rnd();
        mn[to]=f[to],insert(rt[x],to);
    }calc(x,son[x]),f[x]=v[x].get(f[son[x]]);
    return;
}

inline void dfs2(int x)
{
    modify(1,1,n,seg[x],v[x]);
    if(son[x]) 
    {
        top[son[x]]=top[x];
        seg[son[x]]=++seg[0];
        dfs2(son[x]);
    }
    for(int to:go[x]) if(to^son[x])
    {
        top[to]=to;
        seg[to]=++seg[0];
        dfs2(to);
    }
    return;
}

inline void update(int x)
{
    for(;true;x=fa[top[x]])
    {
        calc(x,son[x]);
        modify(1,1,n,seg[x],v[x]);
        int t=top[x];
        if(!fa[t]) break;
        erase(rt[fa[t]],t);
        f[t]=query(1,1,n,seg[t]).get(0);
        insert(rt[fa[t]],t);
    }
    return;
}

int main()
{
    n=read(),m=read();
    mn[0]=f[n+1]=inf,f[0]=-1;
    For(i,2,n) go[fa[i]=read()].push_back(i);
    For(i,1,n) a[i]=read();
    For(i,1,n) b[i]=read();
    top[1]=seg[0]=seg[1]=1;
    dfs1(1),dfs2(1);
    /*
    For(i,1,n) printf("%lld ",f[i]);
    printf("\n");*/
    //return 0;
    For(i,1,m)
    {
        int opt=read(),x=read(),y=read();
        if(opt == 1)
        {
            a[x]=y,update(x);
            int nw=read(),t=fa[x];
            if(t) 
            {
                sum[t]+=nw-b[x],b[x]=nw;
                if(x^son[t])
                {
                    erase(rt[t],x);
                    f[x]=query(1,1,n,seg[x]).get(0);
                    val[x]=b[x],mn[x]=f[x];
                    insert(rt[t],x);
                }update(t);
            }
        }
        else 
        {
            f[x]=query(1,1,n,seg[x]).get(0);
            f[y]=query(1,1,n,seg[y]).get(0);
            //printf("%lld %lld\n",f[x],f[y]);
            bool ans=f[y]>f[x]||f[y]==f[x]&&y>x;
            pc(ans+'0'),pc('\n');
        }
    }
    return 0;
}