#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1e6 + 5;

#define bbit(i) (1<<(i))
#define bdig(x,i) (((x)>>(i))&1)

namespace Trie
{
	const int lb = 20;
	const int MAXP = MAXN * lb;
	int son[MAXP][2], siz[MAXP], pool;
	void init(void)
	{
		for(int i=1; i+1<MAXP; ++i) son[i][0] = i+1;
		pool = 1;
	}
	int new_Node(void)
	{
		int u = pool; pool = son[pool][0];
		son[u][0] = son[u][1] = siz[u] = 0;
		return u;
	}
	void del_Node(int &u)
	{
		son[u][0] = pool;
		pool = u; u = 0;
	}
	void update(int &u,int dep,int x,int k)
	{
		if(!u) u = new_Node();
		if(dep == -1) siz[u] += k;
		else update(son[u][bdig(x,dep)], dep-1, x, k);
		if(!siz[u]) del_Node(u);
	}
	void update(int &rt,int x,int k)
	{
		update(rt, lb-1, x, k);
	}
	int query(int u,int dep,int x,int k)
	{
		if(!siz[u] || dep == -1) return 0;
		if(bdig(x,dep))
			return query(son[u][bdig(k,dep)^1], dep-1, x, k);
		else
		{
			int kk = bdig(k,dep);
			return siz[son[u][kk^1]] + query(son[u][kk], dep-1, x, k);
		}
	}
	int query(int rt,int x,int k)
	{
		return query(rt, lb-1, x, k);
	}
}

struct BIT
{
	int tree[MAXN], n;
	#define lowbit(x) ((x)&-(x))
	inline void update(int x,int k)
	{
		while(x<=n) tree[x] ^= k, x += lowbit(x);
	}
	inline void update(int l,int r,int k)
	{
		update(l,k); update(r+1,k);
	}
	inline int query(int x)
	{
		int res=0;
		while(x) res ^= tree[x], x ^= lowbit(x);
		return res;
	}
}tree;

int n;
vector<int> g[MAXN];

int anc[MAXN], siz[MAXN], sub[MAXN], dfn[MAXN], curdfn = 0;
void dfs_tree(int u,int fa)
{
	anc[u] = fa;
	siz[u] = 1; sub[u] = 0;
	dfn[u] = ++curdfn;
	for(int v: g[u]) if(v != fa)
	{
		dfs_tree(v,u);
		siz[u] += siz[v];
		sub[u] = max(sub[u], sub[v] + 1);
	}
}

void dfs_dep(int u,int fa,int dep[])
{
	for(int v: g[u]) if(v != fa)
		dep[v] = dep[u] + 1, dfs_dep(v,u,dep);
}
inline int getfar(int rt)
{
	static int dep[MAXN];
	dep[rt] = 0; dfs_dep(rt,0,dep);
	return max_element(dep+1,dep+n+1) - dep;
}

int main(void)
{
	int testid,Q;
	scanf("%d%d%d",&testid,&n,&Q);
	for(int i=1; i<n; ++i)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		g[u].push_back(v); g[v].push_back(u);
	}
	if(n == 1)
	{
		while(Q--) printf("0\n");
		return 0;
	}
	
	int ep1 = getfar(1), ep2 = getfar(ep1);
	
	static int dep[2][MAXN];
	dfs_dep(ep1, 0, dep[0]);
	dfs_dep(ep2, 0, dep[1]);
	
	static int type[MAXN], h[MAXN];
	for(int i=1; i<=n; ++i)
	{
		type[i] = dep[0][i] >= dep[1][i]? 0: 1;
		h[i] = max(dep[0][i], dep[1][i]);
	}
	
	int rt1 = -1, rt2 = -1;
	for(int u=1; u<=n; ++u) for(int v: g[u])
		if(type[u] == 0 && type[v] == 1)
			rt1 = u, rt2 = v;
	assert(rt1 != -1);
	
	dfs_tree(rt1, rt2);
	dfs_tree(rt2, rt1);
	
	tree.n = n;
	Trie::init();
	using Trie::update;
	using Trie::query;
	
	static int rt[MAXN];
	for(int i=1; i<=n; ++i) if(i != rt1 && i != rt2)
		update(rt[anc[i]], 0, 1);
	
	static int val[MAXN];
	auto oper = [&] (int u,int k)
	{
		bool flag = u != rt1 && u != rt2;
		if(flag) update(rt[anc[u]], val[u], -1);
		val[u] ^= k;
		if(flag) update(rt[anc[u]], val[u], 1);
		
		tree.update(dfn[u], dfn[u]+siz[u]-1, k);
	};
	auto checkone = [&] (int u) -> int
	{
		return tree.query(dfn[u]) > h[u];
	};
	auto xor_one = [&] (int u)
	{
		oper(rt1, sub[u]); oper(rt2, sub[u]);
		oper(u, sub[u] ^ h[u]);
	};
	
	for(int i=1; i<=n; ++i)
	{
		int x;
		scanf("%d",&x);
		if(x&1) xor_one(i);
	}
	
	while(Q--)
	{
		int x,u;
		scanf("%d%d",&x,&u);
		xor_one(x);
		int ans = checkone(u) + checkone(anc[u])
			+ query(rt[u], h[u]+1, tree.query(dfn[u]));
		printf("%d\n",ans);
	}
	return 0;
}