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

template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
istream& operator>>(istream &s, T &&v) { for (auto &&x : v) s >> x; return s; }
template<ranges::range T, class = enable_if_t<!is_convertible_v<T, string_view>>>
ostream& operator<<(ostream &s, T &&v) { for (auto &&x : v) s << x << ' '; return s; }
 
#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
#define debug(x...) dbg(#x, '=', x, '\n')
#else
#define debug(...) ((void)0)
#endif
 
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second
 
using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using Pt = pair<double, double>;
 
template<class T> inline constexpr T inf = numeric_limits<T>::max() / 2;
constexpr int mod = 1e9 + 7, inv2 = (mod + 1) / 2;
constexpr double eps = 1e-9;
 
template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }

void solve() {
    int m, n, k;
    cin >> m >> n >> k;

    int S, T;
    cin >> S >> T;

    vector<array<int, 3>> edg(m);
    for (auto &[u, v, w] : edg) {
        cin >> u >> v >> w;
    }

    sort(all(edg));

    auto getid = [&](int a, int b) -> int {
        auto it = lower_bound(all(edg), array<int, 3>{a, b, -1});
        if (it == edg.end()) return -1;
        if ((*it)[0] != a or (*it)[1] != b) return -1;
        return it - edg.begin();
    };

    vector<vector<int>> fob(m);
    for (int i = 0; i < k; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        int x = getid(a, b);
        int y = getid(b, c);
        if (x != -1 and y != -1) {
            fob[x].push_back(y);
        }
    }

    for (int i = 0; i < m; i++) {
        sort(all(fob[i]));
    }

    vector<vector<int>> out(n), in(n);
    for (int i = 0; i < m; i++) {
        out[edg[i][0]].push_back(i);
        in[edg[i][1]].push_back(i);
    }
    
    vector G(m, vector<pair<int, i64>>{});

    for (int i = 0; i < n; i++) {
        sort(all(in[i]));
        sort(all(out[i]));

        for (int x : in[i]) {
            for (int y : out[i]) {
                if (!binary_search(all(fob[x]), y)) {
                    G[x].emplace_back(y, edg[y][2]);
                }
            }
        }
    }

    vector<i64> dis(m, inf<i64>);
    priority_queue<pair<i64, int>> pq;
    for (int x : out[S]) {
        chmin<i64>(dis[x], edg[x][2]);
        pq.emplace(-dis[x], x);
    }

    while (!pq.empty()) {
        auto [d, u] = pq.top();
        pq.pop();
        d = -d;
        if (d != dis[u]) continue;
        for (auto [v, w] : G[u]) 
            if (chmin(dis[v], w + d)) {
                pq.emplace(-dis[v], v);
            }
    }

    i64 ans = inf<i64>;
    for (int x : in[T])
        chmin(ans, dis[x]);

    if (ans == inf<i64>) cout << -1 << '\n';
    else cout << ans << '\n';
}
 
signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}