#include <iostream>
#include <assert.h>
#include <stdlib.h>
#include <time.h>
#include <stdio.h>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <string.h>
#include <cmath>
#include <memory.h>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N=100010;
int n,m,k;
vector<vector<int> > g,G;
int dfs,low[N],idx[N],comp[N],cmp,have[N],mn[N];
vector<int> nodes[N];
bool vis[N];
vector<int> S;
bool need[N];
bool in[N];
void DFS(int u){
	idx[u]=low[u]=dfs++;
	vis[u]=true;
	S.push_back(u);
	for(int i=0,v;i<g[u].size();++i){
		v=g[u][i];
		if(!idx[v])
			DFS(v);
		if(vis[v])
			low[u]=min(low[u],low[v]);
	}
	if(low[u]==idx[u]){
		while(true){
			int v=S.back();
			S.pop_back();
			vis[v]=false;
			nodes[cmp].push_back(v);
			comp[v]=cmp;
			mn[cmp]=min(mn[cmp],v);
			if(need[v])
				++have[cmp];
			if(u==v)
				break;
		}
		sort(nodes[cmp].begin(),nodes[cmp].end());
		++cmp;
	}
}
int can[N];
int calc(int u){
	if(can[u]!=-1)
		return can[u];
	can[u]=0;
	for(int i=0;i<g[u].size();++i)
		can[u]=max(can[u],calc(g[u][i]));
	can[u]+=have[u];
	return can[u];
}
vector<int> sol;
bool print(int u,int rem){
	reverse(nodes[u].begin(),nodes[u].end());
	while(have[u]){
		if(need[nodes[u].back()]){
			sol.push_back(nodes[u].back());
			--have[u];
			--rem;
		}
		nodes[u].pop_back();
	}
	if(!rem)
		return true;
	int bestNext=1e9;
	for(int i=0;i<g[u].size();++i)
		if(can[g[u][i]]==rem){
			if(bestNext>mn[g[u][i]])
				bestNext=mn[g[u][i]];
		}
	if(bestNext>1e9-1)
		return false;
	return print(comp[bestNext],rem);
}
int main()
{
	int t;
	scanf("%d",&t);
	while(t--){
		scanf("%d%d%d",&n,&m,&k);
		memset(low,0,sizeof(low));
		memset(idx,0,sizeof(idx));
		memset(vis,0,sizeof(vis));
		for(int i=0;i<=n;++i){
			nodes[i].clear();
			need[i]=false;
			have[i]=0;
			mn[i]=1e9;
			in[i]=false;
			can[i]=-1;
		}
		dfs=1;
		cmp=0;
		g.clear();
		g.resize(n);
		for(int x,i=0;i<k;++i){
			scanf("%d",&x);
			need[x-1]=true;
		}
		k=0;
		for(int i=0;i<n;++i)
			if(need[i])
				++k;
		for(int i=0,a,b;i<m;++i){
			scanf("%d%d",&a,&b);
			--a;--b;
			g[a].push_back(b);
		}
		for(int i=0;i<n;++i)
			if(!idx[i])
				DFS(i);
		G.clear();
		G.resize(cmp+1);
		for(int i=0;i<n;++i)
			for(int j=0;j<g[i].size();++j)
				if(comp[i]!=comp[g[i][j]]){
					G[comp[i]].push_back(comp[g[i][j]]);
					in[comp[g[i][j]]]=true;
				}
		for(int i=0;i<cmp;++i)
			if(in[i]==false)
				G[cmp].push_back(i);
		g.swap(G);
		calc(cmp);
		sol.clear();
		nodes[cmp].push_back(n);
		if(!print(cmp,k))
			puts("-1");
		else{
			for(int i=0;i<sol.size();++i)
				printf("%s%d",i==0?"":" ",sol[i]+1);
			puts("");
		}
	}
	return 0;
}