#include <bits/stdc++.h>

using namespace std;

#define forn(i, x, n) for (int i = int(x); i <= int(n); ++i)
#define for1(i, n, x) for (int i = int(n); i >= int(x); --i)
#define file ""     
#define F first
#define S second 
#define pb push_back   

typedef long long ll; 
typedef pair <int, int> PII;

const int N = 3e5;  
const int INF = 1e9 + 9;

int tests_num;
int n, m, k;
int dlv[N], is_dlv[N];
vector <int> g[N], rg[N], cg[N], cdlv[N];
int used[N], comp[N], comps, order[N], sz;
int du[N], d[N];       

void clear() {
	memset(dlv, 0, sizeof(dlv));
	memset(is_dlv, 0, sizeof(is_dlv));
	memset(used, 0, sizeof(used));
	memset(comp, 0, sizeof(comp));
	memset(order, 0, sizeof(order));
	comps = sz = 0;
	memset(du, 0, sizeof(du));
	memset(d, 0, sizeof(d));
	forn(i, 1, n) {
		g[i].clear();
		rg[i].clear();
		cg[i].clear();
		cdlv[i].clear();
	}	
}

void topSort(int x) {
	if (used[x]) return;
	used[x] = 1;
	for (auto to : g[x])
		topSort(to);
	order[++sz] = x;
}

void revDfs(int x, int color = -1) {
	if (comp[x]) return;
	if (color == -1) color = ++comps;
	comp[x] = color;
	if (is_dlv[x])
		cdlv[color].pb(x);
	for (auto to : rg[x])
		revDfs(to, color);	
}

void condense() {
	forn(i, 1, n)
		topSort(i);
	for1(i, n, 1)
		revDfs(order[i]);
	forn(i, 1, n)
		for (auto to : g[i])
			if (comp[to] != comp[i])
				cg[comp[i]].pb(comp[to]);	
	forn(i, 1, comps)                            
		sort(cdlv[i].begin(), cdlv[i].end());     
}

int dp(int x) {
	if (du[x]) return d[x];
	du[x] = 1;
	d[x] = cdlv[x].size();
	for (auto to : cg[x])                      
		d[x] = max(d[x], dp(to) + (int)cdlv[x].size());
	return d[x];	
}

void restore(int x) {
	for (auto i : cdlv[x])
		cout << i << " ";
	for (auto to : cg[x]) {
		if (d[to] + cdlv[x].size() == d[x]) {
			restore(to);
			return;
    	}
    }     
}

int main () {
#ifdef machine42
	freopen (file"in", "r", stdin);
	freopen (file"out", "w", stdout);
#endif	
	ios_base :: sync_with_stdio (0);
	cin.tie (0);

	cin >> tests_num;
	forn(test, 1, tests_num) {
		cin >> n >> m >> k;
		forn(i, 1, k) {
			cin >> dlv[i];
			is_dlv[dlv[i]] = 1;
		}	
		forn(i, 1, m) {
			int f, t;
			cin >> f >> t;
			g[f].pb(t);
			rg[t].pb(f);
		}	
		condense();                 
		int max_id = 0;                      
		forn(i, 1, comps)
			if (dp(i) > d[max_id])
				max_id = i;                            
		if (d[max_id] != k) {
			cout << "-1\n";
			clear();
			continue;
		}	                                                     
		restore(max_id);
		cout << "\n";
		clear();
	}
	
	return 0;         	
}