//12252024832524
#pragma GCC optimize("Ofast")
#include 
#define TT template
using namespace std; 

typedef long long LL;
const int MAXN = 100005;
int n,m,q;
int ans[MAXN];

LL Read()
{
	LL x = 0,f = 1;char c = getchar();
	while(c > '9' || c < '0'){if(c == '-')f = -1;c = getchar();}
	while(c >= '0' && c <= '9'){x = (x*10) + (c^48);c = getchar();}
	return x * f;
}
TT void Put1(T x)
{
	if(x > 9) Put1(x/10);
	putchar(x%10^48);
}
TT void Put(T x,char c = -1)
{
	if(x < 0) putchar('-'),x = -x;
	Put1(x); if(c >= 0) putchar(c);
}
TT T Max(T x,T y){return x > y ? x : y;}
TT T Min(T x,T y){return x < y ? x : y;}
TT T Abs(T x){return x < 0 ? -x : x;}

int head[MAXN],tot;
struct edge{
	int v,nxt;
}e[MAXN<<1];
void Add_Edge(int u,int v){
	e[++tot] = edge{v,head[u]};
	head[u] = tot;
}
void Add_Double_Edge(int u,int v){
	Add_Edge(u,v);
	Add_Edge(v,u);
}

int f[MAXN],d[MAXN],siz[MAXN],son[MAXN];
void dfs1(int x,int fa){
	d[x] = d[fa] + 1; f[x] = fa; siz[x] = 1;
	for(int i = head[x],v; i ;i = e[i].nxt)
		if((v = e[i].v) ^ fa){
			dfs1(v,x); siz[x] += siz[v];
			if(siz[v] > siz[son[x]]) son[x] = v;
		}
}
int tp[MAXN],dfn[MAXN],dfntot;
void dfs2(int x,int t){
	tp[x] = t; dfn[x] = ++dfntot;
	if(!son[x]) return;
	dfs2(son[x],t);
	for(int i = head[x],v; i ;i = e[i].nxt){
		v = e[i].v;
		if(v == f[x] || v == son[x]) continue;
		dfs2(v,v);
	}
}

vector > Q[MAXN],line[MAXN]; 

int B[MAXN];
int lowbit(int x){return x & -x;}
void Add(int x,int val){for(int i = x;i <= m;i += lowbit(i)) B[i] += val;}
int Sum(int x){int ret = 0;for(int i = x;i >= 1;i ^= lowbit(i)) ret += B[i];return ret;}

struct node{
	int l,r,ID;
	bool operator < (const node &px)const{
		return l < px.l;
	}
};
set s;
void TAdd(int l,int r,int ID){
	if(!s.size()){s.insert(node{l,r,ID});Add(ID,r-l+1);return;}
	auto R = s.upper_bound(node{r,0,0});
	if(R != s.begin()){
		--R;
		if(R->r > r){
			int newl = R->l,newr = r,rr = R->r,nID = R->ID;
			s.erase(R);
			s.insert(node{newl,newr,nID});
			R = s.insert(node{newr+1,rr,nID}).first;
		}
		else ++R;
	}
	auto L = s.lower_bound(node{l,0,0});
	if(L != s.begin()){
		--L;
		if(L->r >= l){
			int newl = L->l,newr = l-1,rr = L->r,nID = L->ID;
			s.erase(L);
			s.insert(node{newl,newr,nID});
			L = s.insert(node{newr+1,rr,nID}).first;
		}
		else ++L;
	}
	for(auto it = L;it != R;++ it) Add(it->ID,-(it->r-it->l+1));
	s.erase(L,R);
	s.insert(node{l,r,ID}); Add(ID,r-l+1);
}
void solve(int sg){
	s.clear();
	for(int i = 1;i <= m;++ i) B[i] = 0;
	for(int i = 1;i <= m;++ i){
		for(auto &A : line[i]) TAdd(A.first,A.second,i);
		for(auto &A : Q[i]) ans[A.second] += sg * (Sum(i) - Sum(A.first-1));
	}
}

int main()
{
	freopen("tree.in","r",stdin);
	freopen("tree.out","w",stdout);
	n = Read(); m = Read(); q = Read();
	for(int i = 1;i < n;++ i) Add_Double_Edge(Read(),Read());
	dfs1(1,0); dfs2(1,1);
	for(int i = 1,u,v;i <= m;++ i) {
		u = Read(),v = Read();
		while(tp[u] ^ tp[v]){
			if(d[tp[u]] < d[tp[v]]) swap(u,v);
			line[i].emplace_back(make_pair(dfn[tp[u]],dfn[u]));
			u = f[tp[u]];
		}
		if(dfn[u] < dfn[v]) swap(u,v);
		if(u ^ v) line[i].emplace_back(make_pair(dfn[v]+1,dfn[u]));
		line[i].emplace_back(make_pair(dfn[v],dfn[v]));
	}
	for(int i = 1;i <= q;++ i){
		int l = Read();
		Q[Read()].emplace_back(make_pair(l,i));
	}
	solve(1);
	for(int i = 1;i <= m;++ i) line[i].pop_back();
	solve(-1);
	for(int i = 1;i <= q;++ i) Put(ans[i],'\n');
	return 0;
}