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

#define FRE(i,a,b)  for(i = a; i <= b; i++)
#define FRL(i,a,b)  for(i = a; i < b; i++)
#define mem(t, v)   memset ((t) , v, sizeof(t))
#define all(x)      x.begin(),x.end()
#define un(x)       x.erase(unique(all(x)), x.end())
#define sf(n)       scanf("%d", &n)
#define sff(a,b)    scanf("%d %d", &a, &b)
#define sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)
#define sl(n)       scanf("%lld", &n)
#define sll(a,b)    scanf("%lld %lld", &a, &b)
#define slll(a,b,c) scanf("%lld %lld %lld", &a, &b, &c)
#define D(x)        cerr << #x " = " << (x) << '\n'
#define DBG         cerr << "Hi" << '\n'
#define pb          push_back
#define PI          acos(-1.00)
#define xx          first
#define yy          second
#define eps         1e-9

typedef unsigned long long int ULL;
typedef long long int LL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;


inline int setBit(int N, int pos) { return N=N | (1<<pos); }
inline int resetBit(int N, int pos) { return N= N & ~(1<<pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1<<pos)); }

//int fx[] = {+0, +0, +1, -1, -1, +1, -1, +1};
//int fy[] = {-1, +1, +0, +0, +1, +1, -1, -1}; //Four & Eight Direction

#define MAX     100000
const LL inf = 1e15;
int n;
vector<pii>E[MAX+10];
struct data{
    LL u, c;
};

bool operator <(data a, data b)
{
    return a.c > b.c;
}
priority_queue<data>Q;
LL dist[MAX+10];
void dijkstra(int src)
{
    for(int i = 1; i<=n; i++)
        dist[i] = inf;
    dist[src] = 0;
    Q.push({src,0});
    while(!Q.empty())
    {
        int u = Q.top().u;
        Q.pop();
        for(int i = 0; i<E[u].size(); i++)
        {
            int v = E[u][i].xx;
            LL w = E[u][i].yy;
            if(dist[u]+w < dist[v])
            {
                dist[v] = dist[u]+w;
                Q.push({v,dist[v]});
            }
        }
    }
}

//1-Based directed graph input
vector<int> g[MAX+5],tree[MAX+5],rg[MAX+5],bucket[MAX+5];
int sdom[MAX+5],par[MAX+5],dom[MAX+5],dsu[MAX+5],label[MAX+5];
int arr[MAX+5],rev[MAX+5],T, source;
void init(int _n, int _source)
{
    T = 0;
    n = _n;
    source = _source;
    for(int i = 1; i<=n; i++)
    {
        g[i].clear(), rg[i].clear(), tree[i].clear(), bucket[i].clear();
        arr[i] = sdom[i] = par[i] = dom[i] = dsu[i] = label[i] = rev[i] = 0;
    }
}
void dfs(int u)
{
    T++;
    arr[u]=T;
    rev[T]=u;
    label[T]=T;
    sdom[T]=T;
    dsu[T]=T;
    for(int i=0; i<g[u].size(); i++)
    {
        int w = g[u][i];
        if(!arr[w])
        {
            dfs(w);
            par[arr[w]]=arr[u];
        }
        rg[arr[w]].push_back(arr[u]);
    }
}

int Find(int u,int x = 0)
{
    if(u==dsu[u])return x?-1:u;
    int v = Find(dsu[u],x+1);
    if(v<0)return u;
    if(sdom[label[dsu[u]]]<sdom[label[u]])
        label[u] = label[dsu[u]];
    dsu[u] = v;
    return x?v:label[u];
}
void Union(int u,int v)  //Add an edge u-->v
{
    dsu[v]=u;
}

void build()
{
    dfs(source);
    for(int i=n; i>=1; i--)
    {
        for(int j=0; j<rg[i].size(); j++)
            sdom[i] = min(sdom[i],sdom[Find(rg[i][j])]);
        if(i>1)bucket[sdom[i]].push_back(i);
        for(int j=0; j<bucket[i].size(); j++)
        {
            int w = bucket[i][j],v = Find(w);
            if(sdom[v]==sdom[w]) dom[w]=sdom[w];
            else dom[w] = v;
        }
        if(i>1)Union(par[i],i);
    }

    for(int i=2; i<=n; i++)
    {
        if(dom[i]!=sdom[i])dom[i]=dom[dom[i]];
//        tree[rev[i]].push_back(rev[dom[i]]);
        tree[rev[dom[i]]].push_back(rev[i]);
    }
}

int deg[MAX+10], weight[MAX+10];
LL ans[MAX+10];
int dfs2(int node)
{
    int ret = 1;
    for(int i = 0; i<tree[node].size(); i++)
    {
        int v = tree[node][i];
        int nw = dfs2(v);
        if(deg[v] == 1)
            ans[nw] = min(ans[nw], (LL)weight[v]);
        ret += nw;
    }
    return ret;
}

int main()
{
    freopen("in2.txt","r",stdin);
    freopen("outta2.txt","w",stdout);
    int i, j, cs, t, u, v, w, m, q;
    sf(t);
    FRE(cs,1,t)
    {
        mem(deg,0);
        sff(n,m);
        FRE(i,1,m)
        {
            sfff(u,v,w);
            E[u].pb({v,w});
            E[v].pb({u,w});
        }
        dijkstra(1);
        FRE(i,0,n)
            ans[i] = inf;
        init(n,1);
        for(int u = 1; u<=n; u++)
        {
            for(int j = 0; j<E[u].size(); j++)
            {
                int v = E[u][j].xx;
                int w = E[u][j].yy;
                if(dist[v] == dist[u] + w)
                    weight[v] = w, g[u].pb(v),deg[v]++;
            }
        }

        for(int u = 1; u<=n; u++)
        {
            for(int j = 0; j<E[u].size(); j++)
            {
                int v = E[u][j].xx;
                int w = E[u][j].yy;
                if(!(dist[v] == dist[u] + w && deg[v] == 1))
                {
                    swap(u,v);
                    if(!(dist[v] == dist[u] + w && deg[v] == 1))
                        ans[0] = min(ans[0], (LL)w);
                    swap(u,v);
                }
            }
        }

        build();
        dfs2(1);
        sf(q);
        printf("Case %d:\n",cs);
        while(q--)
        {
            sf(u);
            if(ans[u] == inf)
                ans[u] = -1;
            printf("%d\n",ans[u]);
        }
        FRE(i,1,n)
            E[i].clear();
    }
    return 0;
}