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

struct TupleHash {
    template <typename T>
    size_t operator()(const T& tuple) const {
        size_t hash = 0;
        std::apply([&hash](auto&&... args) {
            ((hash ^= std::hash<std::decay_t<decltype(args)>>{}(args) + 0x9e3779b9 + (hash << 6) + (hash >> 2)), ...);
        }, tuple);
        return hash;
    }
};

int main(){
    int M,N,K;
    cin>>M>>N>>K;
    int s,t;cin>>s>>t;
    vector<vector<pair<int,int>>> graph(N);
    for(int m=0;m<M;m++){
        int a,b,c;cin>>a>>b>>c;
        graph[a].emplace_back(b,c);
    }
    unordered_set<tuple<int,int,int>,TupleHash> forbidden;
    for(int k=0;k<K;k++){
        int a,b,c;cin>>a>>b>>c;
        forbidden.emplace(a,b,c);
    }
    int inf=1<<30;
    unordered_map<tuple<int,int>,int,TupleHash> dist;
    for(int x=0;x<N;x++){
        for(auto [y,c]:graph[x]){
            dist[{x,y}]=inf;
        }
    }
    priority_queue<tuple<int,int,int>> queue;
    for(auto [y,c]:graph[s]){
        dist[{s,y}]=c;
        queue.emplace(-c,s,y);
    }
    while(!queue.empty()){
        auto [d,x,y]=queue.top();
        queue.pop();
        d=-d;
        for(auto [z,c]:graph[y]){
            if(forbidden.count({x,y,z})){
                continue;
            }
            if(c+d<dist[{y,z}]){
                dist[{y,z}]=c+d;
                queue.push({-(c+d),y,z});
            }
        }
    }
    int ans=inf;
    for(auto [p,d]:dist){
        if(get<1>(p)==t){
            ans=min(ans,d);
        }
    }
    if(ans==inf){
        ans=-1;
    }
    cout<<ans<<"\n";
}