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

const long long INF = 0x1f1f1f1f1f1f1f1f;

template <class T1, class T2>
inline bool minimise(T1 &x, T2 y) {
	if (x > y) { x = y; return true; }
	return false;
}

template <class T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;

template <int N>
class DijkstraGraph {
private:
	int n;
	vector<pair<int, int>> adj[N];

public:
	void init(int _n) {
		n = _n;
		for (int i = 0; i < n; i++)
			adj[i].clear();
	}

	void add_edge(int u, int v, int w) {
		adj[u].emplace_back(v, w);
	}

	long long shortest_path(int s, int t) {
		static long long dist[N];
		min_priority_queue<pair<long long, int>> pq;

		memset(dist, 0x1f, sizeof dist);
		dist[s] = 0;
		pq.emplace(0, s);

		while (not pq.empty()) {
			int u = pq.top().second; pq.pop();
			if (u == t)
				return dist[t];

			for (const auto &e : adj[u]) {
				int v, w;
				tie(v, w) = e;
				if (minimise(dist[v], dist[u] + w))
					pq.emplace(dist[v], v);
			}
		}
		
		return dist[t];
	}
};

const int MAX = 3e4 + 7;
const int MAX_M = 3e5 + 7;
int M, N, K, S, T;

vector<tuple<int, int, int>> edges;
vector<int> enters[MAX], exits[MAX];
vector<pair<int, int>> forbidden[MAX];

void input() {
	cin >> M >> N >> K >> S >> T;
	for (int t = M; t--; ) {
		int u, v, c; cin >> u >> v >> c;
		enters[v].push_back(edges.size());
		exits[u].push_back(edges.size());
		edges.emplace_back(u, v, c);
	}

	for (int t = K; t--; ) {
		int x, y, z; cin >> x >> y >> z;
		forbidden[y].emplace_back(x, z);
	}

	for (int y = 0; y < N; y++)
		sort(forbidden[y].begin(), forbidden[y].end());
}

DijkstraGraph<MAX_M> dgraph;

void solve() {
	dgraph.init(M + 2);

	for (int i = 0; i < M; i++) {
		int u, v, c;
		tie(u, v, c) = edges[i];
		if (u == S)
			dgraph.add_edge(M, i, c);
		if (v == T)
			dgraph.add_edge(i, M + 1, 0);
	}

	for (int u = 0; u < N; u++) {
		for (int i : enters[u]) for (int j : exits[u]) {
			int x, y, c;
			tie(x, ignore, ignore) = edges[i];
			tie(ignore, y, c) = edges[j];

			if (binary_search(forbidden[u].begin(), forbidden[u].end(), make_pair(x, y)))
				continue;

			dgraph.add_edge(i, j, c);
		}
	}

	long long ans = dgraph.shortest_path(M, M + 1);
	if (ans >= INF)
		ans = -1;

	cout << ans;
}
	
int main(void) {
	ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);

	input();
	solve();

	return 0;
}