#include<bits/stdc++.h>

using namespace std;

#ifdef DEBUG
auto&operator<<(auto&o,pair<auto,auto>p){return o<<"("<<p.first<<", "<<p.second<<")";}
auto operator<<(auto&o,auto x)->decltype(x.end(),o){o<<"{";int i=0;for(auto e:x)o<<","+!i++<<e;return o<<"}";}
#define debug(X...)cerr<<"["#X"]: ",[](auto...$){((cerr<<$<<"; "),...)<<endl;}(X)
#else
#define debug(...){}
#endif

#define ll long long
#define pb push_back
#define st first
#define nd second
#define sz(x) (int)(x).size()
#define all(x) (x).begin(),(x).end()
#define FOR(i,l,r) for(int i=(l);i<=(r);i++)
#define ROF(i,r,l) for(int i=(r);i>=(l);i--)
//#define endl '\n'
int inf=1000000007;
ll infl=1000000000000000007;
ll mod=1000000007;

const int N=100007,L=17;

vector<int>G[N];
int s[N];
int c[N];
int ans[N];
vector<pair<int,int>>Q[N];

int pre[N],post[N],cc;
int skok[N][L];
int O[N];

void dfs(int v,int o)
{
	pre[v]=++cc;
	s[v]=1;
	skok[v][0]=o;
	O[v]=o;
	FOR(i,1,L-1) skok[v][i]=skok[skok[v][i-1]][i-1];
	for(auto u:G[v])
	{
		if(u==o) continue;
		dfs(u,v);
		s[v]+=s[u];
	}
	post[v]=cc;
}

bool anc(int u,int v)
{
	return pre[u]<=pre[v]&&post[u]>=post[v];
}

int lca(int u,int v)
{
	if(anc(u,v)) return u;
	ROF(i,L-1,0) if(!anc(skok[u][i],v)) u=skok[u][i];
	return skok[u][0];
}

int head[N],pos[N],it;

void dfs1(int v,int o)
{
	pos[v]=++it;
	int mx=0,p=-1;
	for(auto u:G[v])
	{
		if(u==o) continue;
		if(s[u]>mx)
		{
			mx=s[u];
			p=u;
		}
	}
	if(p==-1) return ;
	head[p]=head[v];
	dfs1(p,v);
	for(auto u:G[v])
	{
		if(u==o||u==p) continue;
		head[u]=u;
		dfs1(u,v);
	}
}

int BIT[N];

void ins(int v,int x)
{
	for(;v<N;v+=v&-v) BIT[v]+=x;
}
int que(int v)
{
	int res=0;
	for(;v>0;v-=v&-v) res+=BIT[v];
	return res;
}

set<pair<pair<int,int>,int>>S;

void upd(int l,int r,int x)
{
	if(l>r) return ;
	debug(S);
	debug(l,r,x);
	vector<pair<pair<int,int>,int>>X;
	X.pb({{r,l},x});
	while(true)
	{
		pair<pair<int,int>,int>p=*S.lower_bound({{l,0},0});
		if(p.st.nd>r) break;
		debug(p.st.nd,p.st.st,p.nd);
		S.erase(p);
		ins(p.nd,-(p.st.st-p.st.nd+1));
		if(p.st.nd<l) X.pb({{l-1,p.st.nd},p.nd});
		if(p.st.st>r) X.pb({{p.st.st,r+1},p.nd});
	}
	for(auto t:X)
	{
		S.insert(t);
		ins(t.nd,t.st.st-t.st.nd+1);
	}
}

void path(int u,int v,int x)
{
	int l=lca(u,v);
	debug(u,v,l);
	while(true)
	{
		if(pos[head[u]]>pos[l]) upd(pos[head[u]],pos[u],x);
		else 
		{
			upd(pos[l]+1,pos[u],x);
			break;
		}
		u=O[head[u]];
	}
	while(true)
	{
		if(pos[head[v]]>pos[l]) upd(pos[head[v]],pos[v],x);
		else 
		{
			upd(pos[l]+1,pos[v],x);
			break;
		}
		v=O[head[v]];
	}
	upd(pos[l],pos[l],x);
}

signed main()
{
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int n,m,q;
	cin>>n>>m>>q;
	FOR(i,1,n-1)
	{
		int a,b;
		cin>>a>>b;
		G[a].pb(b);
		G[b].pb(a);
	}
	dfs(1,1);
	head[1]=1;
	dfs1(1,1);
	FOR(i,1,m) cin>>c[i];
	FOR(i,1,q)
	{
		int l,r;
		cin>>l>>r;
		if(l==r) ans[i]=1;
		else Q[r].pb({l,i});
	}
	S.insert({{n,1},1});
	ins(1,n);
	S.insert({{0,0},0});
	S.insert({{n+1,n+1},0});
	FOR(i,2,m)
	{
		path(c[i-1],c[i],i);
		cout<<i<<endl;
		for(auto [l,j]:Q[i]) ans[j]=n-que(l);
	}
	FOR(i,1,q) cout<<ans[i]<<endl;
	
	return 0;
}