#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


constexpr int INF = 1001001001;

int N, M, S, T;
vector<int> A, B;
int K;
vector<int> X, W;

int dp[1030][35][35];
bool vis[35][35];
int dd[35][35];

int main() {
  for (; ~scanf("%d%d%d%d", &N, &M, &S, &T); ) {
    --S;
    --T;
    A.resize(M);
    B.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    scanf("%d", &K);
    X.resize(K);
    W.resize(K);
    for (int k = 0; k < K; ++k) {
      scanf("%d%d", &X[k], &W[k]);
      --X[k];
    }
    
    vector<int> deg(N, 0);
    vector<vector<int>> graph(N), hparg(N);
    for (int i = 0; i < M; ++i) {
      ++deg[A[i]];
      graph[A[i]].push_back(B[i]);
      hparg[B[i]].push_back(A[i]);
    }
    
    memset(dp, 0, sizeof(dp));
    queue<pair<int, int>> que;
    priority_queue<pair<int, pair<int, int>>> pque;
    for (int p = 0; p < 1 << K; ++p) {
      for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
        dp[p][u][v] = -INF;
        vis[u][v] = false;
        dd[u][v] = deg[u];
      }
      for (int u = 0; u < N; ++u) {
        for (int k = 0; k < K; ++k) if (p & 1 << k) {
          const int v = X[k];
          dp[p][u][v] = -W[k] + dp[p ^ 1 << k][u][v];
          dd[u][v] = 0;
          que.emplace(u, v);
        }
      }
      for (; ; ) {
        int v, w;
        if (!que.empty()) {
          v = que.front().first;
          w = que.front().second;
// cerr<<que.front()<<endl;
          que.pop();
        } else if (!pque.empty()) {
          const int c = pque.top().first;
          v = pque.top().second.first;
          w = pque.top().second.second;
// cerr<<pque.top()<<endl;
          pque.pop();
          if (c <= 0) {
            continue;
          }
        } else {
          break;
        }
        if (vis[v][w]) {
          continue;
        }
        vis[v][w] = true;
        for (const int u : hparg[w]) if (dd[u][v]) {
          --dd[u][v];
          if (chmax(dp[p][u][v], -dp[p][v][w]) || !dd[u][v]) {
            if (!dd[u][v]) {
              que.emplace(u, v);
            } else {
              pque.emplace(dp[p][u][v], make_pair(u, v));
            }
          }
        }
      }
      for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) if (!vis[u][v]) {
        dp[p][u][v] = 0;
      }
/*
cerr<<"p = "<<p<<endl;
for(int u=0;u<N;++u)pv(vis[u],vis[u]+N);
for(int u=0;u<N;++u){for(int v=0;v<N;++v)fprintf(stderr,"%4d ",dp[p][u][v]);cerr<<endl;}
//*/
      for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
        bool jewel = false;
        for (int k = 0; k < K; ++k) if (p & 1 << k) if (X[k] == v) jewel = true;
        if (!jewel) {
          int mx = -INF;
          int vm = -1, wm = -1;
          for (const int w : graph[u]) {
            if (chmax(mx, -dp[p][v][w])) {
              vm = v;
              wm = w;
            }
          }
          if (dp[p][u][v] != mx) {
            cerr << "FAIL " << p << " " << u << " " << v << ": " << dp[p][u][v] << " " << mx << "; " << vm << " " << wm << endl;
            assert(false);
          }
        }
      }
    }
    
    printf("%d\n", dp[(1 << K) - 1][S][T]);
  }
  return 0;
}