#include <iostream>

#include <stdio.h>

#include <string.h>

#include <cstring>

#include <cstdio>

#include <algorithm>

#include <queue>

using namespace std;

const int maxn=0x3f3f3f3f;

int mark,n,m,k,s,t;

int a,b,c;

int ans;

int disS[],disT[]; //disS[i]表示s到i的最短距离，disT[i]表示i到t的最短距离

int vis[];

int tot1=,tot2=;

struct Road{

    int next;

    int to;

}road1[],road2[];

int rlength[];

int head1[],head2[];

//建立正向图

void add1(int x,int y,int l){

    road1[tot1].next=head1[x];

    road1[tot1].to=y;

    rlength[tot1]=l;

    head1[x]=tot1++;

}

//建立反向图

void add2(int x,int y,int l){

    road2[tot2].next=head2[x];

    road2[tot2].to=y;

    rlength[tot2]=l;

    head2[x]=tot2++;

}

struct dij_node{

    int u,dis;

    void init(int uu,int diss){

       u=uu;

       dis=diss;

    }

    bool operator < (const dij_node& tmp) const

    {

        return dis> tmp.dis; //从大到小排

        //优先级队列默认是取“最大”的，即排在最后的，如果从小到大排，则会取最大的出来。

        //因此得从大到小排，这样才能取最小的出来。

    }

};

//s到其它点的距离

void dijkstra1(int v0){

    int idx;

    dij_node temp,minNode;

    priority_queue<dij_node> q;

    memset(disS,maxn,sizeof(disS));

    memset(vis,,sizeof(vis));

    disS[v0]=;

    vis[v0]=;

    temp.init(v0,disS[v0]);

    q.push(temp);

    while(!q.empty()){

        minNode=q.top();

        q.pop();

        idx=minNode.u;

        vis[idx]=;

        for(int k=head1[idx];k!=-;k=road1[k].next){

            int v=road1[k].to;

            if(!vis[v] && disS[idx]+rlength[k]<disS[v]){

                disS[v]=disS[idx]+rlength[k];

                temp.init(v,disS[v]);

                q.push(temp);

            }

        }

    }

}

//其它点到t的距离

void dijkstra2(int v0){

    int idx;

    dij_node temp,minNode;

    priority_queue<dij_node> q;

    memset(disT,maxn,sizeof(disT));

    memset(vis,,sizeof(vis));

    disT[v0]=;

    vis[v0]=;

    temp.init(v0,disT[v0]);

    q.push(temp);

    while(!q.empty()){

        minNode=q.top();

        q.pop();

        idx=minNode.u;

        vis[idx]=;

        for(int k=head2[idx];k!=-;k=road2[k].next){

            int v=road2[k].to;

            if(!vis[v] && disT[idx]+rlength[k]<disT[v]){

                disT[v]=disT[idx]+rlength[k];

                temp.init(v,disT[v]);

                q.push(temp);

            }

        }

    }

}

int main()

{

    scanf("%d",&mark);

    for(int q=;q<=mark;q++){

        memset(head1,-,sizeof(head1));

        memset(head2,-,sizeof(head2));

        //memset(exist,0,sizeof(exist));

        tot1=;tot2=;

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

        scanf("%d%d%d",&k,&s,&t);

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

            scanf("%d%d%d",&a,&b,&c);

            add1(a,b,c);

            add2(b,a,c);//反向图,因为要求出其它点到t点的最短路径，但如果用dijkstra求得话是t到其它点的，因此这里建立反向图

        }

        dijkstra1(s);

        dijkstra2(t);

        ans=maxn;

        bool flag=false;

        for(int p=;p<=k;p++){

            scanf("%d%d%d",&a,&b,&c);

            if(disS[a]<maxn && disS[b]<maxn && disT[a]<maxn && disT[b]<maxn){

                flag=true;

                ans=min(disS[a]+c+disT[b],ans);

                ans=min(disS[b]+c+disT[a],ans);

                ans=min(disS[t],ans);

            }

        }

        if(!flag)

            printf("-1\n");

        else

            printf("%d\n",ans);

    }

    return ;

}