#include <bits/stdc++.h>
using namespace std;
const int NMax = 110;
struct pii {
  int x, y;
};
pii mp(int x, int y) {
  pii ret;
  ret.x = x;
  ret.y = y;
  return ret;
}
int N, M, S, T, K;
int G[NMax][NMax], cnt[NMax], good[NMax][NMax], cost[NMax][NMax];
pii bus[NMax];
vector<int> must[NMax], route[NMax];
int main() {
  memset(G, -1, sizeof(G));
  scanf("%d%d%d%d", &N, &M, &S, &T);
  for (int i = 1; i <= N; i++) G[i][i] = 0;
  for (int i = 1; i <= M; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    G[x][y] = 1;
  }
  for (int k = 1; k <= N; k++)
    for (int i = 1; i <= N; i++)
      if (G[i][k] != -1) {
        for (int j = 1; j <= N; j++)
          if (G[k][j] != -1 && (G[i][j] == -1 || G[i][j] > G[i][k] + G[k][j]))
            G[i][j] = G[i][k] + G[k][j];
      }
  scanf("%d", &K);
  for (int i = 1; i <= K; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    bus[i] = mp(x, y);
    if (G[x][y] == -1) continue;
    memset(cnt, 0, sizeof(cnt));
    for (int j = 1; j <= N; j++)
      if (G[x][j] != -1 && G[j][y] != -1 && G[x][j] + G[j][y] == G[x][y]) {
        cnt[G[x][j]]++;
        route[i].push_back(j);
      }
    for (int j = 1; j <= N; j++)
      if (G[x][j] != -1 && G[j][y] != -1 && G[x][j] + G[j][y] == G[x][y] &&
          cnt[G[x][j]] == 1)
        must[j].push_back(i);
  }
  for (int i = 1; i <= K; i++) {
    int flag = 0;
    for (int j = 0; j < route[i].size(); j++)
      if (route[i][j] == T) {
        flag = 1;
        break;
      }
    if (flag) good[T][i] = 1;
  }
  while (1) {
    int flag = 0;
    for (int i = 1; i <= K; i++) {
      int X = bus[i].x, Y = bus[i].y;
      if (G[X][Y] == -1) continue;
      for (int j = 0; j < route[i].size(); j++) {
        int x = route[i][j];
        int flag1 = 1;
        for (int k = 1; k <= N; k++)
          if (G[x][k] == 1 && G[X][k] == G[X][x] + 1 && G[X][k] != -1 &&
              G[k][Y] != -1 && G[X][k] + G[k][Y] == G[X][Y]) {
            if (!good[k][i]) {
              flag1 = 0;
              break;
            }
          }
        if (!good[x][i]) cost[x][i] = 1000000000;
        if (flag1) {
          int maxx = -1;
          for (int k = 1; k <= N; k++)
            if (G[x][k] == 1 && G[X][k] == G[X][x] + 1 && G[X][k] != -1 &&
                G[k][Y] != -1 && G[X][k] + G[k][Y] == G[X][Y])
              maxx = max(maxx, cost[k][i]);
          if (maxx != -1) {
            good[x][i] = 1;
            if (maxx < cost[x][i]) {
              cost[x][i] = maxx;
              flag = 1;
            }
          }
        }
        int minn = 1000000000;
        for (int k = 0; k < must[x].size(); k++)
          if (good[x][must[x][k]]) {
            int y = must[x][k];
            good[x][i] = 1;
            minn = min(minn, cost[x][y] + 1);
          }
        if (minn < cost[x][i]) {
          cost[x][i] = minn;
          flag = 1;
        }
      }
    }
    if (!flag) break;
  }
  int ret = 1000000000;
  for (int i = 0; i < must[S].size(); i++)
    if (good[S][must[S][i]]) {
      int x = must[S][i];
      ret = min(ret, cost[S][x]);
    }
  if (ret == 1000000000)
    puts("-1");
  else
    printf("%d\n", ret + 1);
  getchar();
  getchar();
  return 0;
}
