// Aditya Shah

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 200005;

typedef pair<int, int> pii;

vector<int> chosen;
set<int> X[N];
vector<int> edges[N];

struct edge {int e, nxt;};
int V, E;
edge e[N], er[N];
int sp[N], spr[N], dp[N];
int group_cnt, group_num[N];
int classifier[N];
bool v[N];
int stk[N];

// Edits

void flush() {
    chosen.clear();
    for (int i = 0; i < N; ++i) {
        edges[i].clear();
        v[i] = false;
        classifier[i] = INT_MAX;
        dp[i] = 0;
        X[i].clear();
        group_num[i] = sp[i] = spr[i] = stk[i] = 0;
    }
    E = 0;
    group_cnt = 0;
}

bool way(pair<int, int> a, pair<int, int> b) {
    if (a.first == b.first) return a.second < b.second;
    return a.first > b.first;
}

void fill_forward(int x)
{
    int i;
    v[x] = true;
    for (i = sp[x]; i; i = e[i].nxt) if (!v[e[i].e]) fill_forward(e[i].e);
    stk[++stk[0]] = x;
}
void fill_backward(int x)
{
    int i;
    v[x] = false;
    group_num[x] = group_cnt;
    for (i = spr[x]; i; i = er[i].nxt) if (v[er[i].e]) fill_backward(er[i].e);
}
void add_edge(int v1, int v2) //add edge v1->v2
{
    e [++E].e = v2; e [E].nxt = sp [v1]; sp [v1] = E;
    er[  E].e = v1; er[E].nxt = spr[v2]; spr[v2] = E;
}
void SCC()
{
    int i;
    stk[0] = 0;
    memset(v, false, sizeof(v));
    for (i = 1; i <= V; i++) if (!v[i]) fill_forward(i);
    group_cnt = 0;
    for (i = stk[0]; i >= 1; i--) if (v[stk[i]]) {group_cnt++; fill_backward(stk[i]);}
}

int dfs(int u) {
    if (v[u]) return dp[u];
    v[u] = true;
    int ans = 0;
    for (int i = 0; i < edges[u].size(); ++i) {
        ans = max(ans, dfs(edges[u][i]));
    }
    dp[u] += ans;
    return dp[u];
}

int main() {
    //freopen("input.in", "r", stdin);
    //freopen("output.out", "w", stdout);
    int T, K, M, x, y;
    scanf("%d", &T);
    while (T--) {

        flush();
        scanf("%d %d %d", &V, &M, &K);

        chosen.resize(K);

        for (int i = 0; i < K; ++i) {
            scanf("%d", &chosen[i]);
        }

        set<pair<int, int> > D;

        for (int i = 0; i < M; ++i) {
            scanf("%d %d", &x, &y);
            if (x == y || D.count(make_pair(x, y)) != 0) continue;
            D.insert(make_pair(x, y));
            add_edge(x, y);
        }

        vector<pair<int, int> > f(D.begin(), D.end());

        M = f.size();

        SCC();

        for (int i = 1; i <= V; ++i) {
            classifier[group_num[i]] = min(classifier[group_num[i]], i);
        }

        for (int i = 0; i < E; ++i) {
            x = classifier[group_num[f[i].first]]; y = classifier[group_num[f[i].second]];
            if (x == y || X[x].count(y) > 0) continue;
            X[x].insert(y);
        }

        for (int i = 1; i <= V; ++i) {
            for (set<int>::iterator it = X[i].begin(); it != X[i].end(); ++it) {
                edges[i].push_back(*it);
            }
        }

        for (int i = 0; i < K; ++i) {
            dp[classifier[group_num[chosen[i]]]]++;
        }

        fill(v, v + N, false);

        bool ok = false;

        for (int i = 0; i < K; ++i) {
            int vis = dfs(classifier[group_num[chosen[i]]]);
            if (vis == K) {
                ok = true;
            }
        }

        if (!ok) {
            printf("-1\n");
            continue;
        }

        set<pair<int, int> > S;
        for (int i = 0; i < K; ++i) {
            S.insert(make_pair(dp[classifier[group_num[chosen[i]]]], chosen[i]));
        }

        vector<pair<int, int> > g(S.begin(), S.end());
        sort(g.begin(), g.end(), way);
        for (int i = 0; i < g.size(); ++i) {
            printf("%d ", g[i].second);
        }
        printf("\n");
    }
    return 0;
}