#pragma comment(linker, "/STACK:1000000000")

 #include <iostream>

 #include <cstdio>

 #include <fstream>

 #include <algorithm>

 #include <cmath>

 #include <deque>

 #include <vector>

 #include <queue>

 #include <string>

 #include <cstring>

 #include <map>

 #include <stack>

 #include <set>

 #define LL long long

 #define MAXN 100005

 #define INF 0x3f3f3f3f

 #define eps 1e-8

 using namespace std;

 struct Edge

 {

     int from, to, dist;

     Edge(int from, int to, int dist):from(from), to(to), dist(dist){};

 };

 struct HeapNode

 {

     int d, u;

     HeapNode(int d, int u):d(d), u(u){};

     bool operator <(const HeapNode& rhs) const{

         return d > rhs.d;

     }

 };

 vector< set<int> > road[MAXN];

 struct Dijstra

 {

     int n, m;

     vector<Edge> edges;

     vector<int> G[MAXN];

     bool done[MAXN];

     int d[MAXN];

     int p[MAXN];

     void init(int n){

         this->n = n;

         for(int i = ; i <= n; i++){

             G[i].clear();

             road[i].clear();

         }

         edges.clear();

     }

     void AddEdge(int from, int to, int dist){

         edges.push_back(Edge(from, to, dist));

         m = edges.size();

         G[from].push_back(m - );

     }

     void dijstra(int s){

         priority_queue<HeapNode> Q;

         for(int i = ; i <= n; i++){

             d[i] = INF;

         }

         d[s] = ;

         memset(done, , sizeof(done));

         Q.push(HeapNode(, s));

         while(!Q.empty()){

             HeapNode x = Q.top();

             Q.pop();

             int u = x.u;

             if(done[u]) continue;

             done[u]  = true;

             for(int i = ; i < G[u].size(); i++){

                 Edge& e = edges[G[u][i]];

                 if(d[e.to] > d[u] + e.dist){

                     d[e.to] = d[u] + e.dist;

                     road[e.to].clear();

                     if(road[u].empty()){

                         set<int> tmp;

                         tmp.clear();

                         tmp.insert(u);

                         road[e.to].push_back(tmp);

                     }

                     else{

                         for(int j = ; j < road[u].size(); j++){

                             road[e.to].push_back(road[u][j]);

                             road[e.to][j].insert(u);

                         }

                     }

                     p[e.to] = G[u][i];

                     Q.push(HeapNode(d[e.to], e.to));

                 }

                 else if(d[e.to] == d[u] + e.dist){

                     int w = road[e.to].size();

                     for(int j = ; j < road[u].size(); j++){

                         road[e.to].push_back(road[u][j]);

                         road[e.to][w + j].insert(u);

                     }

                 }

             }

         }

     }

 };

 int n, m, t, g, h, s;

 Dijstra p;

 vector<int> res;

 int main()

 {

 #ifndef ONLINE_JUDGE

     freopen("in.txt", "r", stdin);

     //freopen("out.txt", "w", stdout);

 #endif // OPEN_FILE

     int T;

     scanf("%d", &T);

     while(T--){

         scanf("%d%d%d", &n, &m, &t);

         scanf("%d%d%d", &s, &g, &h);

         int x, y, z;

         p.init(n);

         for(int i = ; i <= m; i++){

             scanf("%d%d%d", &x, &y, &z);

             p.AddEdge(x, y, z);

             p.AddEdge(y, x, z);

         }

         p.dijstra(s);

         res.clear();

         for(int i = ; i <= t; i++){

             scanf("%d", &x);

             for(int j = ; j < road[x].size(); j++){

                 road[x][j].insert(x);

                 if(road[x][j].find(g) != road[x][j].end() && road[x][j].find(h) != road[x][j].end()){

                     res.push_back(x);

                     break;

                 }

             }

         }

         sort(res.begin(), res.end());

         int w = res.size();

         for(int i = ; i < w; i++){

             printf("%d ", res[i]);

         }

         printf("\n");

     }

 }