#include <bits/stdc++.h>
using namespace std;

#define repu(i, a, b) for (int i = (a); i < (b); ++i)
#define repd(i, a, b) for (int i = (a); i > (b); --i)
#define mem(a, x) memset(a, x, sizeof(a))
#define all(a) a.begin(), a.end()
#define uni(a) a.erase(unique(all(a)), a.end())

typedef long long ll;
const int MOD = 1000000007;

template<class T> inline T tmin(T a, T b) {return (a < b) ? a : b;}
template<class T> inline T tmax(T a, T b) {return (a > b) ? a : b;}
template<class T> inline void amax(T &a, T b) {if (b > a) a = b;}
template<class T> inline void amin(T &a, T b) {if (b < a) a = b;}
template<class T> inline T tabs(T a) {return (a > 0) ? a : -a;}
template<class T> T gcd(T a, T b) {while (b != 0) {T c = a; a = b; b = c % b;} return a;}

const int N = 100005;
int n, a[N], x[N << 1], y[N << 1], par[N];
vector<int> G[N], subG[N], H[N];
vector<int> ord, st;
bool vis[N];

void visit(int v, vector<vector<int>> &scc, stack<int> &S, vector<bool> &inS, vector<int> &low, vector<int> &num, int &time) {
	low[v] = num[v] = ++time;
	S.push(v); inS[v] = true;
	repu(i, 0, G[v].size()) {
		int w = G[v][i];
		if (num[w] == 0) {
			visit(w, scc, S, inS, low, num, time);
			low[v] = min(low[v], low[w]);
		} else if (inS[w]) low[v] = min(low[v], num[w]);
	}
	if (low[v] == num[v]) {
		scc.push_back(vector<int>());
		while (1) {
			int w = S.top(); S.pop(); inS[w] = false;
			scc.back().push_back(w);
			if (v == w) break;
		}
	}
}

void stronglyConnectedComponents(vector<vector<int>> &scc) {
	vector<int> num(n + 1, 0), low(n + 1);
	stack<int> S;
	vector<bool> inS(n + 1);
	int time = 0;
	repu(u, 1, n + 1) if (num[u] == 0) {
		visit(u, scc, S, inS, low, num, time);
	}
}

bool topologicalSort() {
    vector<int> deg(n + 1, 0);
    repu(i, 1, n + 1) repu(j, 0, subG[i].size()) deg[subG[i][j]]++;
    ord.assign(n + 1, -1);
	st.resize(n + 1);
    int t = 0;
    repu(i, 1, n + 1) if (deg[i] == 0) ord[t++] = i, st[i] = t;
    repu(i, 0, t) {
        int v = ord[i];
        repu(j, 0, subG[v].size()) {
            if(--deg[subG[v][j]] == 0) ord[t++] = subG[v][j], st[subG[v][j]] = t;
        }
    }
    return (t == n);
}

bool comp(const int &x, const int &y) {
	return st[x] < st[y];
}

int main(int argc, char *argv[]) {
	ios_base::sync_with_stdio(false);
	
	int ntest, m, k, ver;
	
	cin >> ntest;
	while (ntest--) {
		cin >> n >> m >> k;
        repu(i, 1, n + 1) {
            G[i].clear(); subG[i].clear(); H[i].clear();
        }
		repu(i, 0, k) cin >> a[i];
		repu(i, 0, m) {
			cin >> x[i] >> y[i];
			G[x[i]].push_back(y[i]);
		}
		vector<vector<int>> scc;
		stronglyConnectedComponents(scc);

		repu(i, 0, scc.size()) {
			int mini = *min_element(all(scc[i]));
			repu(j, 0, scc[i].size()) par[scc[i][j]] = mini;
		}
        //repu(i, 1, n + 1) printf("%d\n", par[i]);
		map<pair<int, int>, bool> mp;
		repu(i, 0, m) {
			int px = par[x[i]], py = par[y[i]];
			if (px != py && mp.count({px, py}) == 0) {
				mp[{px, py}] = true;
				subG[px].push_back(py);
			}
		}
		
		topologicalSort();
        //repu(i, 1, n + 1) printf("%d\n", st[i]);
		mem(vis, 0);
		vector<int> pres;
		
		repu(i, 0, k) {
			if (!vis[par[a[i]]]) {
				pres.push_back(par[a[i]]);
				vis[par[a[i]]] = true;
			}
			H[par[a[i]]].push_back(a[i]);
		}
		
		sort(all(pres), comp);
		bool connect = true;
		repd(i, pres.size() - 1, 0) {
			// check pres[i] and pres[i - 1]
			queue<int> que;
			que.push(pres[i - 1]);
			bool ok = false;
			while (que.size()) {
				int cur = que.front(); que.pop();
				repu(j, 0, subG[cur].size()) {
                    ver = subG[cur][j];
					if (ver == pres[i]) ok = true;
					if (st[ver] < st[pres[i]]) que.push(ver);
				}
				if (ok) break;
			}
			if (!ok) {
				connect = false; break;
			}
		}
		
		if (!connect) {
			printf("-1\n"); continue;
		}
		
		repu(i, 0, pres.size()) {
			sort(all(H[pres[i]]));
			repu(j, 0, H[pres[i]].size()) printf("%d ", H[pres[i]][j]);
		}
		printf("\n");
	}
	
	return 0;
}