#include <bits/stdc++.h>
#define debug() puts("qwq"), exit(0)
#define INF 1e9
using namespace std;
const int N = 2e5 + 10;
const int M = 1e6 + 10;

inline int read() {
	char ch = getchar(); int x = 0;
	while (!isdigit(ch)) {ch = getchar();}
	while (isdigit(ch)) {x = (x << 3) + (x << 1) + ch - 48; ch = getchar();}
	return x;
}

struct node {
	int ls, rs, sum;
}t[N * 2 * 2 * 20];
struct Node {
	int opt, x, y, p, q;
}Q[M];
int n, m, T, a[N], b[25], c[25], o[N + M + 25], cnt, depth[N], mx, mem[M][20], lst, dis[25][25];
int root[N], tot, in[N];
int mn[N + M + 25], vis[N + M + 25], sz[N], son[N], id[N], pos[N], num, fa[N], top[N];
vector<int> g[N], G[25], vec[N], to[N], col[N + M + 25], now;

void dfs1(int x, int pa, int d) {
	depth[x] = d; fa[x] = pa; sz[x] = 1; mx = max(mx, d);
	for (auto y : g[x]) {
		if (y == pa) continue;
		dfs1(y, x, d + 1);
		sz[x] += sz[y];
		if (sz[y] > sz[son[x]]) son[x] = y;
	}
}

void dfs2(int x, int anc) {
	top[x] = anc; id[x] = ++num; pos[num] = x;
	if (son[x]) dfs2(son[x], anc);
	for (auto y : g[x]) {
		if (y == fa[x] || y == son[x]) continue;
		dfs2(y, y);
	}
}

inline void clear(int x) {for (int i = id[x]; i < id[x] + sz[x]; ++i) mn[a[pos[i]]] = INF;}
inline void updat(int x) {for (int i = id[x]; i < id[x] + sz[x]; ++i) mn[a[pos[i]]] = min(mn[a[pos[i]]], depth[pos[i]]);}
void dfs3(int x) {
	for (auto y : g[x]) {
		if (y == fa[x] || y == son[x]) continue;
		dfs3(y); clear(y);
	}
	if (son[x]) dfs3(son[x]);
	mn[a[x]] = depth[a[x]];
	for (auto y : g[x]) {
		if (y == fa[x] || y == son[x]) continue;
		updat(y);
	}
	for (auto ID : vec[x])
		for (int i = 1; i <= m; ++i)
			mem[ID][i - 1] = mn[mem[ID][i - 1]];
}

void dfs4(int x, int pa, int anc) {
	for (auto y : G[x]) {
		if (y == pa) continue;
		dis[anc][y] = dis[anc][x] + 1;
		dfs4(y, x, anc);
	}
}

inline int LCA(int x, int y) {
	int fx = top[x], fy = top[y];
	while (fx != fy) {
		if (depth[fx] < depth[fy]) swap(fx, fy), swap(x, y);
		x = fa[fx]; fx = top[x];
	}
	if (id[x] > id[y]) swap(x, y);
	return x;
}

void update(int &rt, int l, int r, int x, int v) {
	if (!rt) rt = ++tot;
	if (l == r) return t[rt].sum += v, void();
	int mid = (l + r) >> 1;
	if (x <= mid) update(t[rt].ls, l, mid, x, v);
	else update(t[rt].rs, mid + 1, r, x, v);
	t[rt].sum = t[t[rt].ls].sum + t[t[rt].rs].sum;
}

void dfs5(int x, int pa) {
//	printf("{%d}\n", x);
	for (auto y : to[x]) {
//		if (x == 3) debug();
		dfs5(y, x);
		in[x] = min(in[x], in[y]);
	}
//	printf("in[%d] = %d\n", x, in[x]);
	update(root[x], 1, mx, in[x], 1);
	if (pa) update(root[pa], 1, mx, in[x], -1);
}

int merge(int x, int y, int l, int r) {
	if (!x || !y) return x | y;
	if (l == r) {
		int z = ++tot;
		t[z].sum = t[x].sum + t[y].sum;
		return z;
	}
	int mid = (l + r) >> 1, z = ++tot;
	t[z].ls = merge(t[x].ls, t[y].ls, l, mid);
	t[z].rs = merge(t[x].rs, t[y].rs, mid + 1, r);
	t[z].sum = t[t[z].ls].sum + t[t[z].rs].sum;
	return z;
}

int query(int rt, int l, int r, int lim) {
	if (!rt) return 0;
	if (lim < l) return 0;
	if (r <= lim) return t[rt].sum;
	int mid = (l + r) >> 1;
	if (mid <= lim) return t[t[rt].ls].sum + query(t[rt].rs, mid + 1, r, lim);
	else return query(t[rt].ls, l, mid, lim);
}

void dfs6(int x) {
	for (auto y : g[x]) {
		if (y == fa[x]) continue;
		dfs6(y);
		root[x] = merge(root[x], root[y], 1, mx);
	}
}

int main() {
	m = read(); n = read(); T = read();
	for (int i = 1, x, y; i < m; ++i) {
		x = read(); y = read();
		G[x].push_back(y);
		G[y].push_back(x);
	}
	for (int i = 1, x, y; i < n; ++i) {
		x = read(); y = read();
		g[x].push_back(y);
		g[y].push_back(x);
	}
	for (int i = 1; i <= m; ++i) o[++cnt] = b[i] = read();
	for (int i = 1; i <= n; ++i) o[++cnt] = a[i] = read();
	for (int i = 1; i <= T; ++i) {
		Q[i].opt = read();
		if (Q[i].opt == 1) {
			Q[i].x = read(); Q[i].y = read();
			Q[i].p = read(); Q[i].q = read();
		}else {
			Q[i].x = read();
			Q[i].y = o[++cnt] = read();
		}
	}
	sort(o + 1, o + 1 + cnt); cnt = unique(o + 1, o + 1 + cnt) - o - 1;
	for (int i = 1; i <= m; ++i) b[i] = lower_bound(o + 1, o + 1 + cnt, b[i]) - o;
	for (int i = 1; i <= n; ++i) a[i] = lower_bound(o + 1, o + 1 + cnt, a[i]) - o;
	for (int i = 1; i <= T; ++i)
		if (Q[i].opt == 2) Q[i].y = lower_bound(o + 1, o + 1 + cnt, Q[i].y) - o;
	for (int i = 1; i <= cnt; ++i) mn[i] = INF;
	for (int i = 1; i <= m; ++i) c[i] = b[i];
	for (int i = 1; i <= T; ++i) {
		if (Q[i].opt == 1) {
			for (int j = 0; j < m; ++j) mem[i][j] = c[j + 1];
			vec[Q[i].y].push_back(i);
		}
		else c[Q[i].x] = Q[i].y;
	}
	dfs1(1, 1, 1); dfs2(1, 1); dfs3(1);
	for (int i = 1; i <= m; ++i) dfs4(i, i, i);
//	debug();
	for (int i = 1; i <= n; ++i) col[a[i]].push_back(i), in[i] = INF;
	for (int ID = 1, cur; ID <= cnt; ++ID) {
//		printf("*[%d] : \n", o[ID]);
		if (col[ID].empty()) continue;
		now.push_back(1);
		for (auto x : col[ID]) now.push_back(x), in[x] = depth[x];
		sort(now.begin(), now.end(), [&](int xx, int yy) {return id[xx] < id[yy];});
		cur = now.size();
		for (int i = 1; i < cur; ++i) now.push_back(LCA(now[i - 1], now[i]));
		sort(now.begin(), now.end(), [&](int xx, int yy) {return id[xx] < id[yy];});
		now.erase(unique(now.begin(), now.end()), now.end());
		for (int i = 1; i < (int)now.size(); ++i) to[LCA(now[i - 1], now[i])].push_back(now[i]);
		dfs5(1, 0);
		for (auto x : now) to[x].clear(), in[x] = INF;
		now.clear();
	}
//	debug();
	dfs6(1);
	for (int ID = 1, x, y, p, q; ID <= T; ++ID) {
		if (Q[ID].opt == 1) {
			x = Q[ID].x, y = Q[ID].y, p = Q[ID].p ^ lst, q = Q[ID].q ^ lst;
			lst = query(root[y], 1, mx, depth[y] + q);
//			printf("{%d}\n", lst);
			for (int i = 1; i <= m; ++i) {
				if (dis[x][i] > p) continue;
				if (vis[b[i]] == ID) continue;
				if (depth[y] + q >= mem[ID][i - 1]) continue;
				lst++; vis[b[i]] = ID;
			}
			printf("%d\n", lst);
		}
		else b[Q[ID].x] = Q[ID].y;
	}
	return 0;
}