#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a, I = b; i <= I; ++i)
#define per(i, a, b) for (int i = a, I = b; i >= I; --i)
using i64 = long long;
using pii = pair<int, int>;
using piii = pair<pii, int>;
template<typename T> void up(T &x, T y) { if (x < y) x = y; }
template<typename T> void down(T &x, T y) { if (x > y) x = y; }

const int N = 31, K = 10, S = 1 << K | 5, M = N * N, inf = 1e9;
int n, m, A, B, k, x[K], w[K], ord[N], all;
vector<int> e1[N], e[M];
int dp[S][M], d[M];
bool vis[M];

int ID(int u, int v) { return (u - 1) * n + v - 1; }
void add_edge(int u, int v) {
    e[u].push_back(v), ++d[v];
}
struct node {
    int u, x;
    bool operator<(const node &rhs) const {
        return abs(x) < abs(rhs.x);
    }
};
void solve(int *dp) {
    priority_queue<node> pq;
    rep(u, 0, all) {
        if (dp[u] > 0 || !d[u]) pq.push({u, dp[u]});
    }
    while (!pq.empty()) {
        auto [u, x] = pq.top();
        pq.pop();
        vis[u] = true;
        if (x != dp[u]) continue;
        if (x < 0) {
            for (auto v : e[u]) {
                if (!vis[v] && dp[v] < -x) {
                    dp[v] = -x;
                    pq.push({v, dp[v]});
                }
            }
        } else {
            for (auto v : e[u]) {
                if (!vis[v] && dp[v] < 0) {
                    up(dp[v], -x);
                    if (!--d[v]) pq.push({v, dp[v]});
                }
            }
        }
    }
    rep(u, 0, all) if (!vis[u]) dp[u] = 0;
    // rep(u, 0, all) cerr << "u = " << u << ", dp = " << dp[u] << endl;
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);

    cin >> n >> m >> A >> B;
    rep(i, 1, m) {
        int u, v;
        cin >> u >> v;
        e1[u].push_back(v);
    }

    memset(ord, -1, sizeof ord);
    cin >> k;
    rep(i, 0, k - 1) {
        cin >> x[i] >> w[i];
        ord[x[i]] = i;
    }
    all = n * n - 1;

    per(s, (1 << k) - 2, 0) {
        memset(d, 0, sizeof d);
        memset(vis, false, sizeof vis);
        rep(i, 0, all) e[i].clear(), dp[s][i] = -inf;
        rep(u, 1, n) rep(v, 1, n) {
            int id = ID(u, v);
            for (auto x : e1[u]) {
                int nid = ID(v, x);
                if (~ord[x] && !(s >> ord[x] & 1)) {
                    int t = s | (1 << ord[x]);
                    up(dp[s][id], -dp[t][nid] + w[ord[x]]);
                } else {
                    add_edge(nid, id);
                }
            }
        }
        solve(dp[s]);
    }
    cout << dp[0][ID(A, B)] << "\n";


    return 0;
}