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

namespace FastIO
{
	const int SIZ1 = 1<<21, SIZ2 = 1<<21;
	char buf1[SIZ1], buf2[SIZ2], *s1=buf1, *t1=buf1, *s2=buf2, *t2=buf2;
	inline char gc(void){ return s1 == t1 && (s1=buf1) == (t1=buf1+fread(buf1,1,SIZ1,stdin))? EOF: *s1++;}
	inline void flush(void){ fwrite(s2,1,t2-s2,stdout); t2=s2;}
	inline void pc(char c){ if(t2-s2==SIZ2) flush(); *t2++ = c;}
	inline int read(void)
	{
		int res=0, flag=1; char c=gc();
		for(; c<'0'||c>'9'; c=gc()) if(c=='-') flag=-1;
		for(; c>='0'&&c<='9'; c=gc()) res=res*10+c-'0';
		return res*flag;
	}
	inline void write(int x)
	{
		if(x>=10) write(x/10);
		pc(x%10+'0');
	}
	inline void write(int x,char c){ write(x); pc(c);}
	struct _{ ~_(void){ flush();}}__;
} using FastIO::read; using FastIO::write;

#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 = 0, pcnt = 0;
	int new_Node(void)
	{
		if(!pool) return ++pcnt;
		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 &rt,int x,int k)
	{
		if(!rt) rt = new_Node();
		static int pt[lb+5];
		pt[lb] = rt; siz[rt] += k;
		for(int i=lb-1; i>=0; --i)
		{
			int &v = son[pt[i+1]][bdig(x,i)];
			if(!v) v = new_Node();
			pt[i] = v; siz[v] += k;
		}
		for(int i=0; i<lb; ++i) if(!siz[pt[i]])
			del_Node(son[pt[i+1]][bdig(x,i)]);
	}
	int query(int rt,int x,int k)
	{
		int res=0;
		for(int i=lb-1; i>=0 && siz[rt]; --i)
		{
			if(bdig(x,i)) rt = son[rt][bdig(k,i)^1];
			else
			{
				int kk = bdig(k,i);
				res += siz[son[rt][kk^1]];
				rt = son[rt][kk];
			}
		}
		return res;
	}
}

struct BIT
{
	int tree[MAXN], alltag, 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=alltag;
		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)
{
	read(); n = read(); int Q = read();
	for(int i=1; i<n; ++i)
	{
		int u = read(), v = read();
		g[u].push_back(v); g[v].push_back(u);
	}
	if(n == 1)
	{
		while(Q--) FastIO::pc('0'), FastIO::pc(' ');
		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);
	
	auto isrt = [&] (int u){ return u == rt1 || u == rt2;};
	dfs_tree(rt1, rt2);
	dfs_tree(rt2, rt1);
	
	static int rt[MAXN], val[MAXN], has[MAXN], num0[MAXN];
	for(int i=1; i<=n; ++i) val[i] = sub[i] ^ h[i];
	
	auto checkone = [&] (int u) -> int
	{
		return tree.query(dfn[u]) > h[u];
	};
	auto xor_one = [&] (int u)
	{
		tree.alltag ^= sub[u];
		has[u] ^= 1;
		if(!isrt(u))
		{
			int k = has[u]? 1: -1;
			Trie::update(rt[anc[u]], val[u], k);
			num0[anc[u]] += -k;
		}
		tree.update(dfn[u], dfn[u]+siz[u]-1, val[u]);
	};
	
	tree.n = n;
	for(int u=1; u<=n; ++u)
	{
		has[u] = read() & 1;
		if(has[u])
		{
			tree.alltag ^= sub[u];
			tree.update(dfn[u], dfn[u]+siz[u]-1, val[u]);
			if(!isrt(u)) Trie::update(rt[anc[u]], val[u], 1);
		}
		else ++num0[anc[u]];
	}
	
	while(Q--)
	{
		int x = read(), u = read();
		xor_one(x);
		
		int k = tree.query(dfn[u]);
		int ans = checkone(u) + checkone(anc[u]);
		ans += Trie::query(rt[u], h[u]+1, k);
		if(k > h[u]+1) ans += num0[u];
		
		write(ans, '\n');
	}
	return 0;
}