/*********************************************************************\
   |--\        ---       /\        |-----------| -----   /-------|    |
   |   \        |       /  \       |               |    /             |
   |    \       |      /    \      |               |   |              |
   |     \      |     /      \     |               |   |----|         |
   |      \     |    / ------ \    |-------|       |        |-----|   |
   |       \    |   /          \   |               |              |   |
   |        \   |  /            \  |               |              /   |
  ---        -------            ------           ----- |---------/    |
                                                                      |
    codeforces = nfssdq  ||  topcoder = nafis007                      |
    mail = nafis_sadique@yahoo.com || nfssdq@gmail.com                |
    IIT,Jahangirnagar University(41)                                  |
                                                                      |
**********************************************************************/

#include <bits/stdc++.h>

using namespace std;

#define xx         first
#define yy         second
#define pb         push_back
#define mp         make_pair
#define LL         long long
#define inf        INT_MAX/3
#define mod        1000000007ll
#define PI         acos(-1.0)
#define linf       (1ll<<60)-1
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define REP(I,N)   FOR(I,0,N)
#define ALL(A)     ((A).begin(), (A).end())
#define set0(ar)   memset(ar,0,sizeof ar)
#define vsort(v)   sort(v.begin(),v.end())
#define setinf(ar) memset(ar,126,sizeof ar)

//cout << fixed << setprecision(20) << p << endl;

template <class T> inline T bigmod(T p,T e,T M){
    LL ret = 1;
    for(; e > 0; e >>= 1){
        if(e & 1) ret = (ret * p) % M;
        p = (p * p) % M;
    } return (T)ret;
}
template <class T> inline T gcd(T a,T b){if(b==0)return a;return gcd(b,a%b);}
template <class T> inline T modinverse(T a,T M){return bigmod(a,M-2,M);}

stack < int > S;
vector < int > vc[100001], rev[100001], scc[100001];
int vis[100001];
void dfs(int c){
    vis[c] = 1;
    REP(i, vc[c].size()) {
        if(vis[vc[c][i]] == 0) dfs(vc[c][i]);
    }
    S.push(c);
}
void dfs1(int c, int p){
    vis[c] = p;
    scc[p].pb(c);
    REP(i, rev[c].size()){
        if(vis[rev[c][i]] == 0) dfs1(rev[c][i], p);
    }
}

int on[100001], deg[100001], order[100001], tar[100001];
pair < int, int > ar[100001];
queue < int > Q;
int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    while(T--){
        int N, M, K; cin >> N >> M >> K;
        FOR(i, 1, N+1) {
            vc[i].clear();
            rev[i].clear();
            scc[i].clear();
        }
        set0(vis);
        REP(i, K) cin >> ar[i].xx;
        REP(i, M){
            int x, y; cin >> x >> y;
            vc[x].pb(y);
            rev[y].pb(x);
        }

        FOR(i, 1, N+1){
            if(vis[i] == 0) dfs(i);
        }

        int cnt = 0;
        set0(vis);
        while(!S.empty()){
            int c = S.top();
            S.pop();
            if(vis[c]) continue;
            cnt++;
            dfs1(c, cnt);
        }

        set0(deg);
        FOR(i, 1, cnt+1){
            REP(j, scc[i].size()){
                REP(k, vc[scc[i][j]].size()){
                    int p = vis[ vc[ scc[i][j] ][ k ] ];
                    if(p != i) deg[p]++;
                }
            }
        }

        FOR(i, 1, cnt+1){
            if(deg[i] == 0) Q.push(i);
        }
        int tmp = 0;
        while(!Q.empty()){
            int c = Q.front(); Q.pop();
            order[c] = tmp;
            tar[tmp++] = c;

            REP(i, scc[c].size()){
                REP(j, vc[ scc[c][i] ].size()){
                    int p = vis[ vc[scc[c][i]][j] ];
                    if(p == c) continue;
                    deg[ p ]--;
                    if(deg[ p ] == 0){
                        Q.push(p);
                    }
                }
            }
        }
        assert(tmp == cnt);

        REP(i, K){
            ar[i].yy = ar[i].xx;
            ar[i].xx = order[ vis[ar[i].yy] ];
        }

        sort(ar, ar + K);
        int fl = 0;
        int ct = 0;
        set0(on);
        REP(i, K){
            if(i == K-1 || ar[i+1].xx == ar[i].xx) continue;

            Q.push(tar[ar[i].xx]);
            ct++;
            on[tar[ar[i].xx]] = ct;
            while(!Q.empty()){
                int c = Q.front(); Q.pop();
                REP(j, scc[c].size()){
                    REP(k, vc[ scc[c][j] ].size()){
                        int p = vis[ vc[scc[c][j]][k] ];
                        if(order[p] > ar[i+1].xx) continue;
                        if(on[p] == ct) continue;
                        on[p] = ct;
                        Q.push(p);
                    }
                }
            }

            if(on[tar[ar[i+1].xx]] != ct){
                fl = 1;
                break;
            }
        }

        if(fl) cout << -1 << endl;
        else {
            REP(i, K) cout << ar[i].yy << " ";
            cout << endl;
        }
    }

}