// Source: https://usaco.guide/general/io

#include <bits/stdc++.h>
using namespace std;

int block = 450;

int n,m,q;
vector<int> adj[100005];
int loc[100005];
vector<array<int,3>> queries[100005];
int tin[100005];
int tout[100005];
int depth[100005];
int up[100005][20];
int bk[100005];
int fd[100005];
int on[100005];
int sparse[200005][20];
int sum;
vector<int> arr;
vector<int> tour;
int timer = 0;

void dfs(int u, int p){
	tour.push_back(u);
	tin[u] = timer++;
	up[u][0] = p;
	depth[u] = depth[p]+1;
	for(int i = 1;i < 20;i++){
		up[u][i] = up[up[u][i-1]][i-1];
	}
	for(auto v : adj[u]){
		if(v != p){
			dfs(v,u);
			tour.push_back(u);
		}
	}
	tout[u] = timer++;
}

bool ancestor(int a, int b){
	return tin[a] <= tin[b] and tout[a] >= tout[b];
}

int lca(int a, int b){
	if(ancestor(a,b)) return a;
	if(ancestor(b,a)) return b;
	for(int i = 19;i >= 0;i--){
		if(!ancestor(up[a][i],b) and up[a][i] != 0){
			a = up[a][i];
		}
	}
	return up[a][0];
}

int lg(int a){
	return 31-__builtin_clz(a);
}

int mindepth(int a, int b){
	if(depth[tour[a]] <= depth[tour[b]]){
		return a;
	}
	return b;
}

int lca2(int a, int b){
	a = tin[a];
	b = tin[b];
	if(a > b){
		swap(a,b);
	}
	int diff = lg(b-a+1);
	return mindepth(sparse[a][diff],sparse[b+1-(1<<diff)][diff]);
}

int dist(int a, int b){
	//cout << "a=" << a << "b=" << b << "lca=" << lca(a,b) << " " << tour[lca2(a,b)] << endl;
	//assert(lca(a,b) == tour[lca2(a,b)]);
	return depth[a]+depth[b]-2*depth[tour[lca2(a,b)]];
}

bool cmp(int a, int b){
	return tin[a] < tin[b];
}

bool cmp2(array<int,3> a, array<int,3> b){
	return a[1] > b[1];
}

void del(int u){
	int right = fd[u];
	int left = bk[u];
	if(left == 0){
		left = bk[n+1];
	}
	if(right == n+1){
		right = fd[0];
	}
	sum -= dist(arr[left],arr[u]);
	sum -= dist(arr[u],arr[right]);
	sum += dist(arr[left],arr[right]);
	fd[bk[u]] = fd[u];
	bk[fd[u]] = bk[u];
}

int main() {
	cin >> n >> m >> q;
	arr.resize(n+1);
	iota(arr.begin(),arr.end(),0);
	for(int i = 0;i < n-1;i++){
		int a,b;
		cin >> a >> b;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	for(int i = 1;i <= m;i++){
		cin >> loc[i];
	}
	for(int i = 0;i < q;i++){
		int l,r;
		cin >> l >> r;
		queries[l/block].push_back({l,r,i});
	}
	depth[1] = 1;
	dfs(1,0);
	for(int i = 0;i < tour.size();i++){
		sparse[i][0] = i;
	}
	for(int i = 1;i < 20;i++){
		for(int j = 0;(j+(1<<i)) < tour.size();j++){
			sparse[j][i] = mindepth(sparse[j][i-1],sparse[j+(1<<(i-1))][i-1]);
		}
	}
	// for(int j = 0;j < tour.size();j++){
	// 	for(int i = 0;i < 20;i++){
	// 		cout << sparse[j][i] << " ";
	// 	}
	// 	cout << endl;
	// }
	sort(arr.begin()+1,arr.end(),cmp);
	int mp[n+1];
	for(int i = 0;i <= n;i++){
		mp[arr[i]] = i;
	}
	int ans[q];
	for(int i = 0;i <= m/block;i++){
		int bl = i*block;
		if(bl == 0){
			bl++;
		}
		sort(queries[i].begin(),queries[i].end(),cmp2);
		memset(bk,0,sizeof(bk));
		memset(fd,0,sizeof(fd));
		memset(on,0,sizeof(on));
		for(int j = bl;j <= m;j++){
			on[mp[loc[j]]]++;
		}
		int last = 0;
		sum = 0;
		for(int j = 1;j <= n;j++){
			if(on[j]){
				bk[j] = last;
				fd[last] = j;
 				if(last != 0){
					sum += dist(arr[last],arr[j]);
					//cout << "sum=" << sum << endl;
				}
				last = j;
			}
		}
		sum += dist(arr[last],arr[fd[0]]);
		fd[last] = n+1;
		bk[n+1] = last;
		int cr = m;
		//cout << "sum=" << sum << endl;
		for(auto [l,r,q] : queries[i]){
			//cout << endl << "l=" << l << "r=" << r << "q=" << q << endl;
			while(cr > r){
				int u = mp[loc[cr--]];
				if(!--on[u]){
					del(u);
				}
			}
			//cout << "SUM=" << sum << endl;
			int tmp = sum;
			for(int j = bl;j < l;j++){
				int u = mp[loc[j]];
				if(!--on[u]){
					del(u);
				}
			}
			//cout << "SUM=" << sum << endl;
			ans[q] = sum/2+1;
			for(int j = l-1;j >= bl;j--){
				int u = mp[loc[j]];
				if(!on[u]++){
					fd[bk[u]] = u;
					bk[fd[u]] = u;
				}
			}
			sum = tmp;
		}
	}
	for(int i = 0;i < q;i++){
		cout << ans[i] << " ";
	}
	cout << endl;
}