#include<bits/stdc++.h>
using std::cin, std::cout;
using ll = long long;
using u64 = unsigned long long;
using db = double;
const int N = 200005;
int n, q, anc[N];
ll a[N], b[N];
struct func {
	ll thres, a, b;
	ll operator () (ll x) const {
		return x >= thres ? a : b;
	}
	func operator () (const func & y) const {
		return {y.thres, (*this)(y.a), (*this)(y.b)};
	}
};
struct seg {
	func o[N << 2]; int L;
	void upt(int x) {
		o[x] = o[x << 1](o[x << 1 | 1]);
	}
	void init(int n) {
		L = 2 << std::__lg(n + 1);
	}
	void upt(int p, const func & v) {
		for(o[p += L] = v;p >>= 1;upt(p));
	}
	func qry(int l, int r) {
		if(l == r) return o[l + L];
		func le = o[l + L], ri = o[r + L];
		l += L, r += L;
		for(;l ^ r ^ 1;l >>= 1, r >>= 1) {
			if((l & 1) == 0) le = le(o[l ^ 1]);
			if((r & 1) == 1) ri = o[r ^ 1](ri);
		}
		return le(ri);
	}
} sgt;


int head[N], next[N];


void link(int fa, int x) {
	next[x] = head[fa], head[fa] = x;
}
int size[N], son[N];
void dfs0(int x) {
	size[x] = 1;
	for(int i = head[x];i;i = next[i]) {
		dfs0(i);
		size[x] += size[i];
		if(size[i] > size[son[x]]) {
			son[x] = i;
		}
	}
}
int dfn[N], top[N], leaf[N], cnt;
void dfs1(int x, int tp) {
	dfn[x] = ++ cnt, top[x] = tp;
	leaf[x] = x;
	if(son[x]) dfs1(son[x], tp), leaf[x] = leaf[son[x]];
	for(int i = head[x];i;i = next[i]) if(i != son[x]) {
		dfs1(i, i);
	}
}
ll get(int p) {
	func f = sgt.qry(dfn[p], dfn[leaf[p]]);
	return f.a;
}
using pr = std::pair<ll, ll>;
namespace TREE {
	pr v[N];
	ll sb[N], min[N];
	int ls[N], rs[N], p[N];
	int st[N], top;
	void update(int x) {
		ll z = 1e18, sum = v[x].second;
		if(ls[x] != 0) z = min[ls[x]], sum += sb[ls[x]];
		z += v[x].second, z = std::min(z, v[x].first);
		if(rs[x] != 0) z += sb[rs[x]], z = std::min(z, min[rs[x]]), sum += sb[rs[x]];
		min[x] = z;
		sb[x] = sum;
	}
	int node(pr x) {
		int p = st[top--];
		ls[p] = rs[p] = 0;
		v[p] = x, update(p);
		return p;
	}
	void init() {
		static std::mt19937 gen;
		top = n;
		for(int i = 1;i <= n;++i) {
			p[i] = gen();
			st[i] = i;
		}
	}
	int merge(int x, int y) {
		if(!x || !y) return x | y;
		if(p[x] > p[y]) {
			rs[x] = merge(rs[x], y);
			update(x);
			return x;
		} else {
			ls[y] = merge(x, ls[y]);
			update(y);
			return y;
		}
	}
	void split(int rt, const pr & w, int & x, int & y) {
		if(!rt) x = y = 0;
		else {
			if(v[rt] < w) {
				split(rs[rt], w, rs[rt], y);
				update(x = rt);
			} else {
				split(ls[rt], w, x, ls[rt]);
				update(y = rt);
			}
		}
	}
	void ins(int & rt, const pr & v) {
		if(!rt) rt = node(v);
		else {
			if(TREE::p[st[top]] >= TREE::p[rt]) {
				int z = node(v);
				split(rt, v, ls[z], rs[z]);
				update(rt = z);
			} else {
				ins(TREE::v[rt] < v ? rs[rt] : ls[rt], v);
				update(rt);
			}
		}
	}
	void del(int & rt, pr v) {
		if(TREE::v[rt] == v) {
			st[++top] = rt;
			rt = merge(ls[rt], rs[rt]);
			return ;
		}
		if(TREE::v[rt] < v) {
			del(rs[rt], v);
		} else {
			del(ls[rt], v);
		}
		update(rt);
	}
	std::pair<bool, ll> qry(int rt, ll w) {
		if(!rt || w <= min[rt]) return {0, w - sb[rt]};
		auto r = qry(rs[rt], w);
		if(r.first) return r;
		w = r.second;
		if(w > v[rt].first) return {1, w};
		w -= v[rt].second;
		return qry(ls[rt], w);
	}
}
struct DS {
	int root;
	ll sumB() const {
		return TREE::sb[root];
	}
	void ins(pr t) {
		TREE::ins(root, t);
	}
	void del(pr t) {
		TREE::del(root, t);
	}
	ll qry(ll sum) {
		auto res = TREE::qry(root, sum);
		return res.second;
	}
} ds[N];
pr old[N];
void reset(int x) {
	ll sum = a[x] + ds[x].sumB() + b[son[x]];
	ll A = ds[x].qry(sum);
	ll B = ds[x].qry(sum - b[son[x]]);
	sgt.upt(dfn[x], {A, B, A});
}
void deal(int p) {
	ds[anc[p]].del(old[p]);
	ds[anc[p]].ins(old[p] = pr(get(p), b[p]));
}
void rereset(int x) {
	for(;x;x = anc[top[x]]) {
		reset(x), deal(top[x]);
	}
}

int main() {
	std::ios::sync_with_stdio(false), cin.tie(0);
	cin >> n >> q;
	for(int i = 2;i <= n;++i) cin >> anc[i], link(anc[i], i);
	dfs0(1);
	dfs1(1, 1);
	for(int i = 1;i <= n;++i) {
		cin >> a[i], a[i] = (ll) a[i] * n + i - 1;
	}
	for(int i = 1;i <= n;++i) {
		cin >> b[i], b[i] = (ll) b[i] * n;
	}
	TREE::init();
	sgt.init(n);
	for(int i = n;i >= 1;--i) {
		reset(i);
		if(son[anc[i]] != i)  {
			old[i] = pr(get(i), b[i]);
			ds[anc[i]].ins(old[i]);
		}
	}
	for(int i = 1, op, p, x, y, c, d;i <= q;++i) {
		cin >> op;
		if(op == 1) {
			cin >> p >> x >> y;
			a[p] = (ll) x * n + p - 1;
			b[p] = (ll) y * n;
			reset(p);
			if(p == top[p]) deal(p);
			rereset(anc[p]);
		} else {
			cin >> c >> d;
			cout << (get(c) < get(d)) << '\n';
		}
	}
	std::cerr << "time : " << double(clock()) / CLOCKS_PER_SEC << '\n';
}