#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <queue>
#include <vector>
#include <cstring>
using namespace std;
int read(){
	int x=0,f=1;char ch = getchar();
	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();}
	return x*f;
}
const int N = 3e5+5;
struct poi{
	int x[2];int id;
}p[N];
bool cmp2(poi a,poi b){
	return a.x[0]<b.x[0];
}
bool cmp3(poi a,poi b){
	return a.x[1]<b.x[1];
}
struct aa{
	int nxt,to;
}edge[N*2];
int head[N],tote,in[N];
void link(int u,int v){
	if(!u||!v){
		return;
	}
	edge[++tote] = (aa){head[u],v};head[u] = tote;
}
queue<int>q;
struct KDT{
	int tot;
	struct aa{
		int lc,rc,L[2],R[2];//0/1表示横纵坐标 LR 是最小最大 
		poi P;
		int mi,tag,val;
	}node[N*3];
	void pushup(int u){
		for(int i=0;i<=1;i++){
			node[u].L[i] = node[u].P.x[i];node[u].R[i] = node[u].P.x[i];
			if(node[u].lc){
				node[u].L[i] = min(node[u].L[i],node[node[u].lc].L[i]);
				node[u].R[i] = max(node[u].R[i],node[node[u].lc].R[i]);
			}
			if(node[u].rc){
				node[u].L[i] = min(node[u].L[i],node[node[u].rc].L[i]);
				node[u].R[i] = max(node[u].R[i],node[node[u].rc].R[i]);
			}
		}
		node[u].mi = min(node[u].val,min(node[node[u].lc].mi,node[node[u].rc].mi));
	}
	void build(int &u,int l,int r,int k){
		if(l>r){
			return;
		}
		if(!u){
			u = ++tot;
		}
		int mid = (l+r)/2;
		if(k==0){
			nth_element(p+l,p+mid,p+r+1,cmp2);
		}else{
			nth_element(p+l,p+mid,p+r+1,cmp3);
		}
		build(node[u].lc,l,mid-1,k^1);
		build(node[u].rc,mid+1,r,k^1);
		
		node[u].P = p[mid];
		node[u].val = in[p[mid].id];
		pushup(u);
//		cout<<"U:"<<u<<" "<<l<<" "<<r<<" "<<node[u].mi<<" "<<p[mid].id<<" "<<node[u].val<<"\n";
	}
	void lazy_tag(int u,int x){
		if(!u){
			return;
		}
		node[u].mi+=x;
		node[u].val+=x;
		node[u].tag+=x;
	}
	void pushdown(int u){
		if(node[u].tag){
			lazy_tag(node[u].lc,node[u].tag);
			lazy_tag(node[u].rc,node[u].tag);
		}
		node[u].tag = 0;
	}
	void upd(int u,int a0,int b0,int a1,int b1,int x){
		if(!u){
			return;
		}
		pushdown(u);
		if(node[u].L[0]>=a0&&node[u].R[0]<=b0&&node[u].L[1]>=a1&&node[u].R[1]<=b1){
//			sta[++top] = u;
			lazy_tag(u,x);
//			cout<<"2:"<<u<<" "<<node[u].val<<" "<<node[u].mi<<"\n";
			return;
		}
		if(b0<node[u].L[0]||a0>node[u].R[0]||b1<node[u].L[1]||a1>node[u].R[1]){
			return;
		}
		poi v = node[u].P;
		if(v.x[0]>=a0&&v.x[0]<=b0&&v.x[1]>=a1&&v.x[1]<=b1){
//			sta[++top] = node[u].P.id;
//			lazy_tag(u,x);
			node[u].val+=x;
//			cout<<"1:"<<u<<" "<<node[u].val<<"\n";
		}
		upd(node[u].lc,a0,b0,a1,b1,x);
		upd(node[u].rc,a0,b0,a1,b1,x);
		
		pushup(u);
//		cout<<"V:"<<u<<" "<<node[u].mi<<" "<<node[u].val<<"\n";
	}
	void ask(int u){
//		cout<<"U:"<<u<<" "<<node[u].val<<" "<<node[u].mi<<"\n";
		if(!u||node[u].mi>0){
			return;
		}
		
		pushdown(u);
		if(node[u].val==0){
			q.push(node[u].P.id);
			node[u].val = 1e9;
		}
		ask(node[u].lc);
		ask(node[u].rc);
		pushup(u);
	}
	void print(int u){
		if(!u){
			return;
		}
		pushdown(u);
//		cout<<"P:"<<u<<" "<<node[u].val<<" "<<node[u].mi<<"\n";
		print(node[u].lc);print(node[u].rc);
	}
}T;
int rt;
int n,m,k;
vector<int>ed[N];
int dep[N],fa[N],tp[N],dfn[N],siz[N],son[N],ct;
void dfs1(int u,int f){
	siz[u] = 1;
	dfn[u] = ++ct;
	for(auto x:ed[u]){
		if(x==f){
			continue;
		}
		dep[x] = dep[u]+1;
		fa[x] = u;
		dfs1(x,u);
		siz[u]+=siz[x];
		if(siz[x]>siz[son[u]]){
			son[u] = x;
		}
	}
}
void dfs2(int u,int t){
	tp[u] = t;
	if(!son[u]){
		return;
	}
	dfs2(son[u],t);
	for(auto x:ed[u]){
		if(x==fa[u]||x==son[u]){
			continue;
		}
		dfs2(x,x);
	}
}
int Lca(int u,int v){
	while(tp[u]!=tp[v]){
		if(dep[tp[u]]<dep[tp[v]]){
			swap(u,v);
		}
		u = fa[tp[u]];
	}
	if(dep[u]<dep[v]){
		swap(u,v); 
	}
	return v;
}
int U[N],V[N];
int getrt(int u,int t){
	while(tp[u]!=tp[t]){
		if(fa[tp[u]]==t){
			return tp[u];
		}
		u = fa[tp[u]];
	}
	return son[t];
} 
void ask(int l1,int r1,int l2,int r2,int x){
	if(l1>r1||l2>r2){
		return;
	}
	if(l1>l2){
		swap(l1,l2);swap(r1,r2);
	}
//	cout<<"LR:"<<l1<<" "<<r1<<" "<<l2<<" "<<r2<<"\n";
	T.upd(rt,l1,r1,l2,r2,x);
}
void Link(int i,int x){
	int u=U[i],v=V[i];
	int L = Lca(u,v);
	if(L==u){
		int R = getrt(v,u);
//		cout<<"R:"<<R<<" "<<v<<" "<<u<<"\n";
		ask(1,dfn[R]-1,dfn[v],dfn[v]+siz[v]-1,x);
		ask(dfn[R]+siz[R],n,dfn[v],dfn[v]+siz[v]-1,x);
	}else{
		ask(dfn[u],dfn[u]+siz[u]-1,dfn[v],dfn[v]+siz[v]-1,x);
	}
}
int sta[N],top;
signed main(){
	n = read();m = read();k = read();
	T.tot = m;T.node[0].mi = 1e9;
	for(int i=1;i<n;i++){
		int u,v;
		u = read();v = read();
		ed[u].push_back(v);ed[v].push_back(u);
	}
	dfs1(1,0);
	dfs2(1,1);
	
	for(int i=1;i<=m;i++){
		in[i]--;
		U[i] = read();V[i] = read();
		if(dfn[U[i]]>dfn[V[i]]){
			swap(U[i],V[i]);
		}
		p[i].x[0] = dfn[U[i]];p[i].x[1] = dfn[V[i]];p[i].id = i;
	}
	for(int i=1;i<=k;i++){
		int u,v;
		u = read();v = read();
		link(v,u);in[u]++;
	}
	T.build(rt,1,m,0);
	for(int i=1;i<=m;i++){
//		cout<<"i:"<<i<<"\n";
		Link(i,1);
		
//		T.print(rt);
	}
//	cout<<"hrer:"<<T.node[rt].mi<<"\n";
	T.ask(rt);
	while(!q.empty()){
		int u = q.front();
		q.pop();
//		cout<<"U:"<<u<<"\n";
		sta[++top] = u;
//		cout<<u<<" ";
		Link(u,-1);
		for(int i=head[u];i;i=edge[i].nxt){
			int now = edge[i].to;
			T.upd(rt,dfn[U[now]],dfn[U[now]],dfn[V[now]],dfn[V[now]],-1);
		}
		T.ask(rt);
	}
	for(int i=top;i>=1;i--){
		cout<<sta[i]<<" ";
	}
	return 0;
}