#include <bits/stdc++.h>

using namespace std;

const int N = 2e5 + 5;

int n, q;
vector<int> G[N];
int fa[N], siz[N], son[N], dep[N];

void dfs1(int x) {
    siz[x] = 1;
    for (auto v : G[x]) {
        dep[v] = dep[x] + 1;
        dfs1(v);
        siz[x] += siz[v];
        if (siz[v] > siz[son[x]]) son[x] = v;
    }
}

int edp[N], top[N], dfn[N], dfn_c;

void dfs2(int x) {
    dfn[x] = ++dfn_c;
    if (!son[x]) {
        edp[x] = x;
        return;
    }
    top[son[x]] = top[x];
    dfs2(son[x]), edp[x] = edp[son[x]];
    for (auto v : G[x]) {
        if (v != son[x]) dfs2(top[v] = v);
    }
}

mt19937 rnd;

struct Node {
    int ls, rs, id;
    long long f, b, sb, mn;
    unsigned int key;
} p[N];

int rt[N], tot;
vector<int> rub;

int newNode() {
    if (rub.empty()) return ++tot;
    int x = rub.back();
    rub.pop_back();
    return x;
}

void delNode(int x) {
    rub.push_back(x);
}

void pushup_p(int k) {
    p[k].sb = p[p[k].ls].sb + p[p[k].rs].sb + p[k].b;
    p[k].mn = p[p[k].ls].sb + p[k].f;
    if (p[k].ls) p[k].mn = min(p[k].mn, p[p[k].ls].mn);
    if (p[k].rs) p[k].mn = min(p[k].mn, p[p[k].rs].mn + p[p[k].ls].sb + p[k].b);
}

void split(int k, long long F, int ID, int &x, int &y) {
    if (!k) {
        x = y = 0;
        return;
    }
    if (p[k].f > F || (p[k].f == F && p[k].id > ID)) {
        x = k;
        split(p[k].rs, F, ID, p[x].rs, y);
    } else {
        y = k;
        split(p[k].ls, F, ID, x, p[y].ls);
    }
    pushup_p(k);
}

int merge(int x, int y) {
    if (!x || !y) return x + y;
    if (p[x].key < p[y].key) {
        p[x].rs = merge(p[x].rs, y);
        pushup_p(x);
        return x;
    }
    p[y].ls = merge(x, p[y].ls);
    pushup_p(y);
    return y;
}

void insert_p(int &x, long long F, long long B, int ID) {
    int k = newNode();
    p[k].ls = p[k].rs = 0, p[k].id = ID;
    p[k].f = F, p[k].b = p[k].sb = B, p[k].mn = F;
    p[k].key = rnd();
    int le, ri;
    split(x, F, ID, le, ri);
    x = merge(merge(le, k), ri);
}

void erase_p(int &x, long long F, long long, int ID) {
    int le, mid, ri;
    split(x, F, ID, le, mid);
    split(mid, F, ID + 1, mid, ri);
    delNode(mid);
    x = merge(le, ri);
}

int find_p(int x, long long y) {
    if (!x || p[x].mn >= y) return 0;
    if (!p[x].ls && !p[x].rs) return x;
    int ans = find_p(p[x].ls, y);
    if (ans) return ans;
    if (p[p[x].ls].sb + p[x].f < y) return x;
    return find_p(p[x].rs, y - p[p[x].ls].sb - p[x].b);
}

long long query_p(int &x, int y) {
    int le, ri;
    split(x, p[y].f, p[y].id, le, ri);
    long long S = p[le].sb;
    x = merge(le, ri);
    return S;
}

long long A[N], B[N], sB[N];

struct Info {
    long long mid, le, ri;

    long long get(long long x) {
        return (x <= mid ? le : ri);
    }

    Info operator + (Info y) {
        Info res;
        res.mid = mid;
        res.le = y.get(le);
        res.ri = y.get(ri);
        return res;
    }
} s[1 << 19];

void pushup_s(int k) {
    s[k] = s[k << 1 | 1] + s[k << 1];
}

void update_s(int k, int l, int r, int x, Info y) {
    if (l == r) {
        s[k] = y;
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) update_s(k << 1, l, mid, x, y);
    else update_s(k << 1 | 1, mid + 1, r, x, y);
    pushup_s(k);
}

Info query_s(int k, int l, int r, int x, int y) {
    if (l >= x && r <= y) return s[k];
    int mid = (l + r) >> 1;
    if (y <= mid) return query_s(k << 1, l, mid, x, y);
    if (x > mid) return query_s(k << 1 | 1, mid + 1, r, x, y);
    return query_s(k << 1 | 1, mid + 1, r, x, y) + query_s(k << 1, l, mid, x, y);
}

void updateF(int x) {
    if (!son[x]) return;
    int pos = find_p(rt[x], A[x] + sB[x]);
    Info res;
    if (pos == 0) {
        res.mid = A[x] + B[son[x]] - 1;
        res.le = A[x] + B[son[x]];
        res.ri = A[x];
    } else {
        long long v = A[x] + sB[x] - query_p(rt[x], pos);
        res.mid = v - 1, res.le = v;
        pos = find_p(rt[x], A[x] + sB[x] - B[son[x]]);
        if (pos == 0) res.ri = A[x];
        else {
            v = A[x] + sB[x] - query_p(rt[x], pos);
            res.ri = v;
        }
    }
    update_s(1, 1, n, dfn[x], res);
}

long long getF(int x) {
    if (G[x].empty()) return A[x];
    return query_s(1, 1, n, dfn[x], dfn[edp[x]] - 1).get(A[edp[x]]);
}

long long f[N];

void record(int x) {
    f[x] = getF(x);
    if (x != 1) f[fa[x]] = getF(fa[x]);
    x = top[fa[fa[x]]];
    while (x) f[x] = getF(x), x = top[fa[x]];
}

void remove(int x) {
    auto del = [&](int id) {
        if (fa[id] && son[fa[id]] != id) erase_p(rt[fa[id]], f[id], B[id], id);
    };
    del(x);
    if (x != 1) del(fa[x]);
    x = top[fa[fa[x]]];
    while (x) del(x), x = top[fa[x]];
}

void reset(int id, long long x, long long y) {
    if (id != 1) sB[fa[id]] += y - B[id];
    A[id] = x, B[id] = y;
}

void append(int x) {
    auto add = [&](int id) {
        updateF(id);
        if (fa[id] && son[fa[id]] != id) insert_p(rt[fa[id]], getF(id), B[id], id);
    };
    add(x);
    if (x != 1) add(fa[x]);
    x = top[fa[fa[x]]];
    while (x) add(x), x = top[fa[x]];
}

signed main() {
    scanf("%d%d", &n, &q);
    for (int i = 2; i <= n; ++i) {
        scanf("%d", &fa[i]);
        G[fa[i]].push_back(i);
    }
    dfs1(dep[1] = 1);
    dfs2(top[1] = 1);
    for (int i = 1; i <= n; ++i) {
        scanf("%lld", &A[i]);
    }
    for (int i = 1; i <= n; ++i) {
        scanf("%lld", &B[i]);
        if (fa[i]) sB[fa[i]] += B[i];
    }
    for (int i = n; i >= 1; --i) {
        updateF(i);
        if (fa[i] && son[fa[i]] != i) {
            insert_p(rt[fa[i]], getF(i), B[i], i);
        }
    }
    while (q--) {
        int opt; scanf("%d", &opt);
        if (opt == 1) {
            int id;
            long long x, y;
            scanf("%d%lld%lld", &id, &x, &y);
            record(id);
            remove(id);
            reset(id, x, y);
            append(id);
        } else {
            int x, y; scanf("%d%d", &x, &y);
            long long fx = getF(x), fy = getF(y);
            if (fx > fy || (fx == fy && x > y)) puts("0");
            else puts("1");
        }
    }
    return 0;
}