#include <bits/stdc++.h>
using namespace std;
#define For(Ti,Ta,Tb) for(auto Ti=(Ta);Ti<=(Tb);++Ti)
#define Dec(Ti,Ta,Tb) for(auto Ti=(Ta);Ti>=(Tb);--Ti)
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define range(Tx) begin(Tx),end(Tx)
using ll=long long;
const int N=2005,V=N*N*4;
int n,m,q,tag[N],cnt[N],fa[N],fai[N];
vector<pair<int,int>> e[N];
vector<int> A[N];
void get_fa(int u){
	for(auto [v,i]:e[u]){
		if(v!=fa[u]){
			fa[v]=u;
			fai[v]=i;
			get_fa(v);
		}
	}
}
int siz[N],dep[N],hson[N];
void dfs1(int u){
	siz[u]=1;
	dep[u]=dep[fa[u]]+1;
	for(auto [v,i]:e[u]){
		if(v!=fa[u]){
			dfs1(v);
			siz[u]+=siz[v];
			if(siz[v]>siz[hson[u]]){
				hson[u]=v;
			}
		}
	}
}
int dfn[N],rk[N],dfx,top[N];
void dfs2(int u,int tp){
	rk[dfn[u]=++dfx]=u;
	top[u]=tp;
	if(hson[u]){
		dfs2(hson[u],tp);
	}
	for(auto [v,i]:e[u]){
		if(v!=fa[u]&&v!=hson[u]){
			dfs2(v,v);
		}
	}
}
int mn[N][12];
int argmin(int u,int v){
	return dfn[u]<dfn[v]?u:v;
}
void build(){
	dep[0]=-1;
	For(i,1,n) mn[i][0]=fa[rk[i]];
	For(j,1,11){
		For(i,1,n-(1<<j)+1){
			mn[i][j]=argmin(mn[i][j-1],mn[i+(1<<(j-1))][j-1]);
		}
	}
}
int lca(int u,int v){
	if(u==v) return u;
	if((u=dfn[u])>(v=dfn[v])) swap(u,v);
	int k=__lg(v-(u++));
	return argmin(mn[u][k],mn[v-(1<<k)+1][k]);
}
// 0 -> up, 1 -> down
// i: edge, j: item
int id(int i,int j,bool one){
	return (j-1)*(n-1)+i+one*m*(n-1);
}
int tot;
template<int N,typename T=short>
struct DSU{
	T n,fa[N];
	void init(int _n){
		n=_n;
		For(i,1,n) fa[i]=i;
	}
	int find(int u){
		for(;u!=fa[u];u=fa[u]=fa[fa[u]]);
		return u;
	}
	void merge(int u,int v){
		fa[find(u)]=find(v);
	}
};
DSU<N*N,int> dsu;
struct Edge{
	int v,nxt;
}edg[int(3e7)];
int bel[V],head[V],ecnt;
void add_edge(int u,int v){
	u=bel[u];
	v=bel[v];
	edg[++ecnt]={v,head[u]};
	head[u]=ecnt;
}
void dfs(int u,int i,int len){
	cnt[u]=(tag[u]==i);
	for(auto [v,_]:e[u]){
		if(v!=fa[u]){
			dfs(v,i,len);
			cnt[u]+=cnt[v];
		}
	}
	if(u>1){
		if(!cnt[u]){
			add_edge(id(fai[u],i,1),id(fai[u],i,0));
		}else if(cnt[u]==len){
			add_edge(id(fai[u],i,0),id(fai[u],i,1));
		}
	}
}
struct Two_Sat{
	struct Vert{
		int dfn,low,bel;
		bool in;
	}t[V];
	int dfx,scc_cnt,stk[V],top;
	void tarjan(int u){
		t[u].dfn=t[u].low=++dfx;
		stk[++top]=u;
		t[u].in=1;
		for(int i=head[u];i;i=edg[i].nxt){
			int v=edg[i].v;
			if(!t[v].dfn){
				tarjan(v);
				t[u].low=min(t[u].low,t[v].low);
			}else if(t[v].in){
				t[u].low=min(t[u].low,t[v].dfn);
			}
		}
		if(t[u].low==t[u].dfn){
			++scc_cnt;
			while(1){
				int v=stk[top--];
				t[v].bel=scc_cnt;
				t[v].in=0;
				if(v==u) break;
			}
		}
	}
	void solve(){
		For(i,1,tot){
			if(!t[i].dfn){
				tarjan(i);
			}
		}
	}
}sat;
int color(int u){
	return sat.t[bel[u]].bel;
}
struct Rollback_DSU{
	int fa[N],siz[N];
	vector<int> op;
	int find(int u){
		return u==fa[u]?u:find(fa[u]);
	}
	void init(){
		For(i,1,m){
			fa[i]=i;
			siz[i]=1;
		}
	}
	void merge(int u,int v){
		u=find(u);
		v=find(v);
		if(u!=v){
			if(siz[u]<siz[v]){
				swap(u,v);
			}
			fa[v]=u;
			siz[u]+=siz[v];
			op.push_back(v);
		}
	}
	void undo(unsigned ver){
		while(op.size()>ver){
			int v=op.back();
			op.pop_back();
			siz[fa[v]]-=siz[v];
			fa[v]=v;
		}
	}
}dsu2;
struct Segment_Tree{
	DSU<N> dsu[N*4];
	void init(int p=1,int L=2,int R=n){
		dsu[p].init(m);
		if(L==R) return;
		int mid=(L+R)/2;
		init(p*2,L,mid);
		init(p*2+1,mid+1,R);
	}
	void range_link(int l,int r,int u,int v,int p=1,int L=2,int R=n){
		if(l<=L&&R<=r){
			dsu[p].merge(u,v);
			return;
		}
		int mid=(L+R)/2;
		if(l<=mid) range_link(l,r,u,v,p*2,L,mid);
		if(r>mid) range_link(l,r,u,v,p*2+1,mid+1,R);
	}
	void iterate(int p=1,int L=2,int R=n){
		auto ver=dsu2.op.size();
		For(i,1,m){
			dsu2.merge(dsu[p].fa[i],i);
		}
		if(L==R){
			if(L>1){
				int i=fai[rk[L]];
				For(j,1,m){
					::dsu.merge(id(i,dsu2.fa[j],0),id(i,j,0));
				}
			}
			dsu2.undo(ver);
			return;
		}
		int mid=(L+R)/2;
		iterate(p*2,L,mid);
		iterate(p*2+1,mid+1,R);
		dsu2.undo(ver);
	}
}seg;
int main(){
	cin.tie(nullptr)->sync_with_stdio(false);
	#ifdef LOCAL
	assert(freopen("B.in","r",stdin));
	assert(freopen("B.out","w",stdout));
	#endif
	cin>>n>>m>>q;
	For(i,1,n-1){
		int u,v;
		cin>>u>>v;
		e[u].emplace_back(v,i);
		e[v].emplace_back(u,i);
	}
	get_fa(1);
	dfs1(1);
	dfs2(1,1);
	build();
	tot=m*(n-1)*2;
	For(i,1,m){
		int len;
		cin>>len;
		A[i].resize(len);
		For(j,0,len-1) cin>>A[i][j];
	}
	dsu.init(m*(n-1));
	seg.init();
	For(_,1,q){
		vector<int> V,S;
		int lV,lS;
		cin>>lV;
		V.resize(lV);
		For(i,0,lV-1) cin>>V[i];
		cin>>lS;
		S.resize(lS);
		For(i,0,lS-1) cin>>S[i];
		sort(range(V),[](int u,int v){
			return dfn[u]<dfn[v];
		});
		vector<pair<int,int>> chains;
		static int stk[N];
		int len=0;
		stk[len=1]=1;
		for(int u:V){
			int lca=::lca(u,stk[len]);
			if(lca!=stk[len]){
				while(len>1&&dfn[stk[len-1]]>dfn[lca]){
					chains.emplace_back(stk[len-1],stk[len]);
					--len;
				}
				chains.emplace_back(lca,stk[len]);
				if(stk[len-1]!=lca) stk[len]=lca;
				else --len;
			}
			stk[++len]=u;
		}
		For(i,1,len-1){
			chains.emplace_back(stk[i],stk[i+1]);
		}
		auto merge=[&](int u,int v,int i,int j){
			while(top[u]!=top[v]){
				if(dep[top[u]]<dep[top[v]]){
					swap(u,v);
				}
				seg.range_link(dfn[top[u]],dfn[u],i,j);
				u=fa[top[u]];
			}
			if(u!=v){
				if(dfn[u]<dfn[v]){
					swap(u,v);
				}
				seg.range_link(dfn[v]+1,dfn[u],i,j);
			}
		};
		For(i,0,lS-2){
			for(auto [u,v]:chains){
				merge(u,v,S[i],S[i+1]);
			}
		}
	}
	dsu2.init();
	seg.iterate();
	{
		int x=m*(n-1);
		For(i,1,x){
			bel[i]=dsu.find(i);
		}
		For(i,x+1,x*2){
			bel[i]=bel[i-x]+x;
		}
		For(i,x*2+1,x*4){
			bel[i]=i;
		}
	}
	debug("%d\n",int(clock()));
	For(i,1,m){
		for(int u:A[i]){
			tag[u]=i;
		}
		dfs(1,i,A[i].size());
		vector<int> pre(n+1),suf(n+1);
		For(u,1,n){
			int cur=0;
			for(auto [v,j]:e[u]){
				if(v!=fa[u]){
					pre[v]=cur;
					if(cur){
						++tot;
						add_edge(tot,cur);
						add_edge(tot,id(j,i,0));
						cur=tot;
					}else{
						cur=id(j,i,0);
					}
				}
			}
			reverse(range(e[u]));
			cur=0;
			for(auto [v,j]:e[u]){
				if(v!=fa[u]){
					suf[v]=cur;
					if(cur){
						++tot;
						add_edge(tot,cur);
						add_edge(tot,id(j,i,0));
						cur=tot;
					}else{
						cur=id(j,i,0);
					}
				}
			}
			reverse(range(e[u]));
			for(auto [v,j]:e[u]){
				if(v!=fa[u]){
					if(u>1){
						add_edge(id(j,i,1),id(fai[u],i,1));
					}
					if(pre[v]){
						add_edge(id(j,i,1),pre[v]);
					}
					if(suf[v]){
						add_edge(id(j,i,1),suf[v]);
					}
				}else if(cur){
					add_edge(id(j,i,0),cur);
				}
			}
		}
	}
	debug("tot=%d,ecnt=%d\n",tot,ecnt);
	debug("%d\n",int(clock()));
	sat.solve();
	debug("%d\n",int(clock()));
	For(i,1,n-1){
		For(j,1,m){
			if(color(id(i,j,0))==color(id(i,j,1))){
				cout<<"-1\n";
				return 0;
			}
		}
	}
	For(j,1,m){
		For(u,1,n){
			bool flg=1;
			for(auto [v,i]:e[u]){
				flg&=(color(id(i,j,1))<color(id(i,j,0)))==(v==fa[u]);
			}
			if(flg){
				cout<<u<<' ';
				break;
			}
		}
	}
	cout<<'\n';
	return 0;
}