#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

#define uint unsigned

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

constexpr int N = 2e5 + 9;
int n, m, p[N], a[N], b[N];
LL sb[N], f[N];
vi g[N];

namespace FHQ {
  int rt[N];

  struct {
    LL s, mn;
    int ch[2]; uint p;
  } t[N];

  /**
   * @param s \sum_{i \in subtree(u)} b_i
   * @param mn \min_{i \in subtree(u)} s_{i - 1} + f_i
  */

#define ls(p) t[p].ch[0]
#define rs(p) t[p].ch[1]

  void up (int p) {
    t[p].s = t[ls(p)].s + t[rs(p)].s + b[p];
    t[p].mn = min({t[ls(p)].mn, t[ls(p)].s + f[p], t[ls(p)].s + b[p] + t[rs(p)].mn});
  }

  void spl (LL k1, int k2, int p, int &x, int &y) {
    if (!p) {
      x = y = 0;
      return;
    }
    if (f[p] > k1 || (f[p] == k1 && p >= k2)) {
      x = p;
      spl(k1, k2, rs(p), rs(x), y);
    } else {
      y = p;
      spl(k1, k2, ls(p), x, ls(y));
    }
    up(p);
  }

  int merge (int x, int y) {
    if (!x || !y) {
      return x | y;
    }
    if (t[x].p < t[y].p) {
      rs(x) = merge(rs(x), y);
      up(x);
      return x;
    } else {
      ls(y) = merge(x, ls(y));
      up(y);
      return y;
    }
  }
  
  LL qry (int p, LL y) {
    p = rt[p];
    while (p) {
      if (t[ls(p)].mn < y) {
        p = ls(p);
        continue;
      } 
      y -= t[ls(p)].s;
      if (f[p] < y) {
        return y;
      }
      y -= b[p];
      p = rs(p);
    }
    return y;
  }

  void ins (int x) {
    int y = p[x], i, j;
    spl(f[x], x, rt[y], i, j);
    t[x].mn = f[x], t[x].s = b[x], t[x].p = rng();
    rt[y] = merge(i, merge(x, j));
  }

  void era (int x) {
    int y = p[x], i, j, k;
    spl(f[x], x, rt[y], i, j);
    spl(f[x], x + 1, i, i, k);
    assert(k == x);
    rt[y] = merge(i, j);
  }

#undef ls
#undef rs
}

struct F {
  LL k, x, y;

  LL operator () (LL p) const {
    return p < k ? x : y;
  }

  F operator + (const F &rhs) const {
    return {rhs.k, operator()(rhs.x), operator()(rhs.y)};
  }
};

namespace SGT {

#define ls p << 1
#define rs p << 1 | 1
#define m ((l + r) >> 1)

  F t[N << 2];

  void up (int p) {
    t[p] = t[ls] + t[rs];
  }

  void mdy (int s, int l, int r, int p, F x) {
    if (l == r) {
      t[p] = x;
      return;
    }
    s <= m ? mdy(s, l, m, ls, x) : mdy(s, m + 1, r, rs, x);
    up(p);
  }

  F qry (int ql, int qr, int l, int r, int p) {
    if (ql <= l && r <= qr) {
      return t[p];
    }
    if (qr <= m) {
      return qry(ql, qr, l, m, ls);
    }
    if (m < ql) {
      return qry(ql, qr, m + 1, r, rs);
    }
    return qry(ql, qr, l, m, ls) + qry(ql, qr, m + 1, r, rs);
  }

#undef m
}

int sz[N], son[N], top[N], bot[N], dfn[N], dfc;

F h[N];

F func (int u) {
  if (sz(g[u])) {
    LL k = FHQ::qry(u, a[u] + sb[u]);
    return {k, k, FHQ::qry(u, a[u] + sb[u] - b[son[u]])};
  } else {
    return {0, 0, a[u]};
  }
}

LL val (int u) {
  return SGT::qry(dfn[u], dfn[bot[u]], 1, n, 1)(0);
}

void dfs1 (int u) {
  sz[u] = 1;
  for (int v : g[u]) {
    dfs1(v);
    sb[u] += b[v];
    sz[u] += sz[v];
    if (sz[v] > sz[son[u]]) {
      son[u] = v;
    }
  }
  for (int v : g[u]) {
    if (v ^ son[u]) {
      FHQ::ins(v);
    }
  }
  h[u] = func(u);
  f[u] = h[u](f[son[u]]);
}

void dfs2 (int u, int t) {
  top[u] = t;
  dfn[u] = ++dfc;
  SGT::mdy(dfc, 1, n, 1, h[u]);
  if (son[u]) {
    dfs2(son[u], t);
    bot[u] = bot[son[u]];
  } else {
    bot[u] = u;
  }
  for (int v : g[u]) {
    if (v ^ son[u]) {
      dfs2(v, v);
    }
  }
}

void upd (int u) {
  while (true) {
    SGT::mdy(dfn[u], 1, n, 1, h[u] = func(u));
    u = top[u];
    if (u == 1) {
      return;
    }
    FHQ::era(u);
    f[u] = val(u);
    FHQ::ins(u);
    u = p[u];
  }
}

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  L (i, 2, n) {
    cin >> p[i];
    g[p[i]].eb(i);
  }
  L (i, 1, n) {
    cin >> a[i];
  }
  L (i, 1, n) {
    cin >> b[i];
  }
  FHQ::t[0].mn = numeric_limits<LL>::max() / 2;
  dfs1(1);
  dfs2(1, 1);
  while (m--) {
    int o;
    cin >> o;
    if (o == 1) {
      int u, x, y;
      cin >> u >> x >> y;
      a[u] = x;
      upd(u);
      if (u > 1) {
        sb[p[u]] += y - b[u];
        if (u == top[u]) {
          FHQ::era(u);
          b[u] = y;
          FHQ::ins(u);
        } else {
          b[u] = y;
        }
        upd(p[u]);
      }
    } else {
      int p, q;
      cin >> p >> q;
      LL x = val(p), y = val(q);
      cout << (x < y || (x == y && p < q)) << '\n';
    }
  }
}
// I love WHQ!