#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
  t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
  t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
  puts(f ? "YES" : "NO");
  exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
  assert(y >= 0);
  x += y;
  if (x >= mod) x -= mod;
  assert(x >= 0 && x < mod);
}
void et(int x = -1) {
  printf("%d\n", x);
  exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
  long long ans = 1;
  while (y > 0) {
    if (y & 1) ans = (x * ans) % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
class MaxFlow {
 public:
  long long cap[100000], flow[100000];
  int to[100000], prev[100000], last[5000], used[5000], level[5000];
  int V, E;
  MaxFlow(int n) {
    V = n;
    E = 0;
    for (int(i) = 0; (i) < (int)(V); (i)++) last[i] = -1;
  }
  void init(int n, int es) {
    V = n;
    E = 0;
    for (int(i) = 0; (i) < (int)(V); (i)++) last[i] = -1;
    for (int(i) = 0; (i) < (int)(V); (i)++) {
      used[i] = 0;
      level[i] = 0;
    }
    for (int(i) = 0; (i) < (int)(es); (i)++) {
      cap[i] = flow[i] = to[i] = prev[i] = 0;
    }
  }
  void add_edge(int x, int y, long long f) {
    cap[E] = f;
    flow[E] = 0;
    to[E] = y;
    prev[E] = last[x];
    last[x] = E;
    E++;
    cap[E] = 0;
    flow[E] = 0;
    to[E] = x;
    prev[E] = last[y];
    last[y] = E;
    E++;
  }
  bool bfs(int s, int t) {
    int i;
    for (int(i) = 0; (i) < (int)(V); (i)++) level[i] = -1;
    queue<int> q;
    q.push(s);
    level[s] = 0;
    while (!q.empty()) {
      int x = q.front();
      q.pop();
      for (i = last[x]; i >= 0; i = prev[i])
        if (level[to[i]] == -1 && cap[i] > flow[i]) {
          q.push(to[i]);
          level[to[i]] = level[x] + 1;
        }
    }
    return (level[t] != -1);
  }
  long long dfs(int v, int t, long long f) {
    int i;
    if (v == t) return f;
    for (i = used[v]; i >= 0; used[v] = i = prev[i])
      if (level[to[i]] > level[v] && cap[i] > flow[i]) {
        long long tmp = dfs(to[i], t, min(f, cap[i] - flow[i]));
        if (tmp > 0) {
          flow[i] += tmp;
          flow[i ^ 1] -= tmp;
          return tmp;
        }
      }
    return 0;
  }
  vector<pair<int, int> > positive_edges() {
    vector<pair<int, int> > ans;
    for (int(i) = 0; (i) < (int)(V); (i)++)
      for (int j = last[i]; j >= 0; j = prev[j])
        if (cap[j] - flow[j] > 0) ans.push_back(make_pair(i, to[j]));
    return ans;
  }
  long long maxflow(int s, int t) {
    while (bfs(s, t)) {
      for (int(i) = 0; (i) < (int)(V); (i)++) used[i] = last[i];
      while (dfs(s, t, (1LL << 60)) != 0)
        ;
    }
    long long ans = 0;
    for (int i = last[s]; i >= 0; i = prev[i]) ans += flow[i];
    return ans;
  }
};
int dis[105][105], s, b, h;
struct ship {
  int x, a, f, p;
  int pro = -1;
  void rd() { scanf("%d%d%d%d", &x, &a, &f, &p); }
} sp[100035];
struct baase {
  int x, d, g;
  void rd() { scanf("%d%d%d", &x, &d, &g); }
} bs[100035];
int baseInf[105][100035 * 2];
int u[100035], v[100035], pos[100035];
bool vis[100035];
long long ans;
void cal2() {
  for (int(i) = 1; (i) <= (int)(k); (i)++) {
    scanf("%d%d", u + i, v + i);
    vis[u[i]] = 1;
    vis[v[i]] = 1;
  }
  for (int(i) = 1; (i) <= (int)(s); (i)++)
    if (!vis[i] && sp[i].pro > sp[i].p) {
      ans += sp[i].pro - sp[i].p;
    }
  vector<int> vp;
  for (int(i) = 1; (i) <= (int)(s); (i)++)
    if (vis[i]) {
      vp.push_back(i);
      pos[i] = vp.size();
    }
  int N = vp.size();
  int S = 0, T = N + 1;
  MaxFlow mf = MaxFlow(T + 5);
  for (int(i) = 0; (i) < (int)(N); (i)++) {
    int id = vp[i];
    if (sp[id].pro >= sp[id].p) {
      mf.add_edge(S, i + 1, sp[id].pro - sp[id].p);
      ans += sp[id].pro - sp[id].p;
    } else {
      if (sp[id].pro == -1)
        mf.add_edge(i + 1, T, (1LL << 60));
      else
        mf.add_edge(i + 1, T, sp[id].p - sp[id].pro);
    }
  }
  for (int(i) = 1; (i) <= (int)(k); (i)++) {
    int x = u[i], y = v[i];
    mf.add_edge(pos[x], pos[y], (1LL << 60));
  }
  ans -= mf.maxflow(S, T);
  printf("%lld\n", ans);
}
void fmain(int tid) {
  scanf("%d%d", &n, &m);
  for (int(i) = 1; (i) <= (int)(n); (i)++)
    for (int(j) = 1; (j) <= (int)(n); (j)++)
      dis[i][j] = i == j ? 0 : (1000000000) + 5;
  for (int(i) = 1; (i) <= (int)(m); (i)++) {
    int u, v;
    scanf("%d%d", &u, &v);
    if (u == v) continue;
    dis[u][v] = dis[v][u] = 1;
  }
  for (int(k) = 1; (k) <= (int)(n); (k)++)
    for (int(i) = 1; (i) <= (int)(n); (i)++)
      for (int(j) = 1; (j) <= (int)(n); (j)++)
        mintt(dis[i][j], dis[i][k] + dis[k][j]);
  scanf("%d%d%d", &s, &b, &k);
  for (int(i) = 1; (i) <= (int)(s); (i)++) sp[i].rd();
  for (int(i) = 1; (i) <= (int)(b); (i)++) bs[i].rd();
  map<int, int> hsh;
  int cnt = 0;
  for (int(i) = 1; (i) <= (int)(s); (i)++) hsh[sp[i].a];
  for (int(i) = 1; (i) <= (int)(b); (i)++) hsh[bs[i].d];
  for (auto& p : hsh) p.second = ++cnt;
  for (int(i) = 1; (i) <= (int)(s); (i)++) sp[i].a = hsh[sp[i].a];
  for (int(i) = 1; (i) <= (int)(b); (i)++) bs[i].d = hsh[bs[i].d];
  memset(baseInf, -1, sizeof(baseInf));
  for (int(j) = 1; (j) <= (int)(b); (j)++) {
    maxtt(baseInf[bs[j].x][bs[j].d], bs[j].g);
  }
  for (int(i) = 1; (i) <= (int)(n); (i)++)
    for (int(j) = 1; (j) <= (int)(cnt); (j)++)
      maxtt(baseInf[i][j], baseInf[i][j - 1]);
  for (int(i) = 1; (i) <= (int)(s); (i)++) {
    for (int(j) = 1; (j) <= (int)(n); (j)++)
      if (dis[sp[i].x][j] <= sp[i].f) {
        maxtt(sp[i].pro, baseInf[j][sp[i].a]);
      }
  }
  cal2();
}
int main() {
  int t = 1;
  for (int(i) = 1; (i) <= (int)(t); (i)++) {
    fmain(i);
  }
  return 0;
}
