#include "circuit.h"

#include <vector>
#include <bits/stdc++.h>

using namespace std;

namespace {

const int N = 2e5 + 7;
const int md = 1e9 + 2022;

int add(int a, int b) {
	return a + b < md ? a + b : a + b - md;
}

int mul(int a, int b) {
	return a * 1ll * b % md;
}

int n, m;
int p[N], a[N];
int h[N];
int dp[N];
int sz[N];
vector<int> g[N];
int kek[N];

struct node {
	int s, s1;
};

node merge(const node &l, const node &r) {
	node ret;
	ret.s = add(l.s, r.s);
	ret.s1 = add(l.s1, r.s1);
	return ret;
}

node t[4 * N];
int d[4 * N];

void apply(int v, int x) {
	if (x) {
		swap(t[v].s, t[v].s1);
	}
	d[v] ^= x;
}

void push(int v) {
	apply(2 * v, d[v]);
	apply(2 * v + 1, d[v]);
	d[v] = 0;
}

void upd(int v, int tl, int tr, int l, int r, int x) {
	if (tl >= r || tr <= l) {
		return;
	}
	if (tl >= l && tr <= r) {
		apply(v, x);
		return;
	}
	push(v);
	int tm = (tl + tr) / 2;
	upd(2 * v, tl, tm, l, r, x);
	upd(2 * v + 1, tm, tr, l, r, x);
	t[v] = merge(t[2 * v], t[2 * v + 1]);
}

void build(int v, int tl, int tr) {
	d[v] = 0;
	if (tr - tl == 1) {
		t[v].s = a[tl] == 1 ? kek[tl] : 0;
		t[v].s1 = a[tl] == 0 ? kek[tl] : 0;
		return;
	}
	int tm = (tl + tr) / 2;
	build(2 * v, tl, tm);
	build(2 * v + 1, tm, tr);
	t[v] = merge(t[2 * v], t[2 * v + 1]);
}

void dfsdp(int v) {
	dp[v] = v >= n ? 1 : sz[v];
	for (int u : g[v]) {
		dfsdp(u);
		dp[v] = mul(dp[v], dp[u]);
	}
}

void dfskek(int v) {
	if (sz[v] == 0) {
		return;
	}
	{
		vector<int> pref(sz[v] + 1, 1), suf(sz[v] + 1, 1);
		for (int i = 0; i < sz[v]; ++i) {
			pref[i + 1] = mul(pref[i], dp[g[v][i]]);
			suf[i + 1] = mul(suf[i], dp[g[v][sz[v] - i - 1]]);
		}
		for (int i = 0; i < sz[v]; ++i) {
			int u = g[v][i];
			kek[u] = mul(kek[v], mul(pref[i], suf[sz[v] - i - 1]));
		}
	}
	for (int u : g[v]) {
		dfskek(u);
	}
}

}

void init(int grdn, int grdm, vector<int> grdp, vector<int> grda) {
	n = grdn;
	m = grdm;
	for (int i = 0; i < n + m; ++i) {
		p[i] = grdp[i];
	}
	for (int i = 0; i < m; ++i) {
		a[n + i] = grda[i];
	}
	h[0] = 0;
	for (int i = 1; i < n + m; ++i) {
		h[i] = h[p[i]] + 1;
		g[p[i]].push_back(i);
	}
	for (int i = 0; i < n + m; ++i) {
		sz[i] = g[i].size();
	}
	dfsdp(0);
	kek[0] = 1;
	dfskek(0);
	build(1, 0, n + m);
}

int count_ways(int grdl, int grdr) {
	int l = grdl;
	int r = grdr;
	++r;
	upd(1, 0, n + m, l, r, 1);
	return t[1].s;
}