// spnauT
//
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int _b=(b),i=(a); i<_b; ++i)
#define ROF(i,b,a) for(int _a=(a),i=(b); i>_a; --i)
#define REP(n) for(int _n=(n); --_n>=0;)
#define _1 first
#define _2 second
#define PB(x) push_back(x)
#define SZ(x) int((x).size())
#define ALL(x) (x).begin(), (x).end()
#define MSET(m,v) memset(m,v,sizeof(m))
#define MAX_PQ(T) priority_queue <T>
#define MIN_PQ(T) priority_queue <T,vector<T>,greater<T>>
#define IO() {ios_base::sync_with_stdio(0); cin.tie(0);}
#define nl '\n'
#define cint1(a) int a; cin>>a
#define cint2(a,b) int a,b; cin>>a>>b
#define cint3(a,b,c) int a,b,c; cin>>a>>b>>c
typedef long long LL;
typedef pair<int,int> PII;
typedef vector<int> VI; typedef vector<LL> VL; typedef vector<PII> VP;
template<class A, class B> inline bool mina(A &x, B y) {return(y<x)?(x=y,1):0;}
template<class A, class B> inline bool maxa(A &x, B y) {return(x<y)?(x=y,1):0;}
template<class A, class B> inline A geta(A &x, const B y) {A t=x;x=y;return t;}

class Digraph1
{
public:
	int N; vector<VI> E;
	Digraph1(int n = 0) {N = n; E.resize(n);}
	inline void addEdge(int a, int b) {E[a].PB(b);}
};

class SCC1
{
public:
	int N, cn;
	VI dt, low, par, cid;
	vector<VI> scc, SE;

	SCC1(){}
	SCC1(const Digraph1 &G, bool buildSE)
	{
		N = G.N; cn = 0;
		VI ds, ccs, ccsd, ai, V;
		ds.reserve(N); ccs.reserve(N);
		ccsd.resize(N); ai.resize(N); V.resize(N,0);
		dt.resize(N); low.resize(N); par.resize(N); cid.resize(N);
		int dti = 0;

		FOR(i,0,N) if(!V[i])
		{
			int dsn = 0, ccsn = 0;
			ds[dsn++] = ccs[ccsd[i] = ccsn++] = i; par[i] = -1;
			while(dsn > 0)
			{
				int u = ds[dsn-1];
				if(V[u] == 0)
				{
					V[u] = 1;
					dt[u] = low[u] = dti++;
					ai[u] = G.E[u].size()-1;
				}
				int end = 1;
				while(ai[u] >= 0)
				{
					int v = G.E[u][ai[u]];
					if(V[v] != 0 && par[v] == u)
					{
						mina(low[u], low[v]);
						--ai[u];
						continue;
					}

					if(V[v] == 0)
					{
						ds[dsn++] = ccs[ccsn++] = v;
						par[v] = u;
						end = 0; break;
					}
					else
					{
						if(V[v] == 1) mina(low[u], dt[v]);
						--ai[u];
					}
				}
				if(end)
				{
					--dsn;
					if(low[u] == dt[u]) // u is the root of a new SCC
					{
						int p = ccsn-1;
						while(p >= 0 && ccs[p] != u) --p;
						scc.PB(VI()); scc[cn].reserve(ccsn - p);
						FOR(j,p,ccsn)
						{
							int w = ccs[j];
							V[w] = 2;
							scc[cid[w] = cn].PB(w);
						}
						++cn; ccsn = p;
					}
				}
			}
		}

		if(buildSE)
		{
			// unique edges only, no self-loop
			SE.resize(cn);
			FOR(u,0,N) for(int v: G.E[u]) if(cid[u] != cid[v]) SE[cid[u]].PB(cid[v]);
			for(VI &se: SE)
			{
				sort(se.begin(), se.end());
				se.resize(distance(se.begin(), unique(se.begin(), se.end())));
			}
		}
	}
};

#define MAXN (100005)

int N, M, K;
int A[MAXN];
int B[MAXN];
int C[MAXN];
int dp[MAXN];
int F[MAXN];

int main()
{
	IO();
	cint1(T);
	REP(T)
	{
		MSET(B,0);
		cin >> N >> M >> K;
		FOR(i,0,K)
		{
			cint1(a);
			--a;
			A[i] = a;
			B[a] = 1;
		}

		Digraph1 G(N);
		FOR(i,0,M)
		{
			cint2(a,b);
			--a; --b;
			G.addEdge(a,b);
		}

		SCC1 S(G,1);
		/*
		printf("cn %d   %d  %d\n", S.cn, (int)SZ(S.scc), (int)SZ(S.SE));
		FOR(i,0,S.cn)
		{
			printf("scc %d (%d) ", i, SZ(S.scc[i]));
			for(int a: S.scc[i]) printf(" %d", a);
			printf(" - ");
			for(int v: S.SE[i]) printf(" %d", v);
			putchar('\n');
		}*/

		MSET(C,0);
		FOR(i,0,K) ++C[S.cid[A[i]]];

		int res1 = 0;
		int resi = 0;
		FOR(i,0,S.cn)
		{
			int res = 0;
			F[i] = -1;
			for(int v: S.SE[i]) if(maxa(res, dp[v])) F[i] = v;
			dp[i] = res + C[i];
			if(maxa(res1, dp[i])) resi = i;
		}

		if(res1 < K) cout << -1 << nl;
		else
		{
			int u = resi;
			while(u != -1)
			{
				if(C[u] > 0)
				{
					sort(ALL(S.scc[u]));
					for(int a: S.scc[u]) if(B[a]) cout << a+1 << ' ';
				}
				u = F[u];
			}
			cout << nl;
		}
	}

	return 0;
}