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

#define rep(i, n) for (int i = 0; i < (int)(n); i++)

int main()
{
    long long N, M;
    cin >> N >> M;

    assert(1 <= N && N <= 2 * 100'000);
    assert(1 <= M && M <= min(2 * 100'000ll, N * (N - 1) / 2));

    vector<vector<int>> graph(N);
    set<pair<int, int>> uv;

    rep(i, M)
    {
        int u, v;
        cin >> u >> v;
        assert(1 <= u && u <= N);
        assert(1 <= v && v <= N);
        assert(u != v);
        assert(!uv.contains({u, v}));
        assert(!uv.contains({v, u}));

        uv.insert({u, v});
        uv.insert({v, u});

        u--, v--;
        graph[u].push_back(v);
        graph[v].push_back(u);
    }

    vector<int> observe_dists(N, -1);

    int L;
    cin >> L;
    assert(1 <= L && L <= N);

    rep(i, L)
    {
        int J, K;
        cin >> J >> K;
        assert(1 <= J && J <= N);
        assert(0 <= K && K <= 1'000);

        J--;
        observe_dists[J] = max(observe_dists[J], K);
    }

    priority_queue<pair<int, int>> pq;
    rep(i, N)
    {
        if (observe_dists[i] == -1)
        {
            continue;
        }
        pq.push({observe_dists[i], i});
    }

    while (pq.size())
    {
        auto [dist, now] = pq.top();
        pq.pop();
        if (dist == 0 || observe_dists[now] != dist)
        {
            continue;
        }

        for (int next : graph[now])
        {
            if (dist - 1 <= observe_dists[next])
            {
                continue;
            }

            observe_dists[next] = dist - 1;
            pq.push({dist - 1, next});
        }
    }

    vector<int> dists(N, -1);
    queue<int> qu;

    if (observe_dists[0] == -1)
    {
        dists[0] = 0;
        qu.push(0);
    }

    while (qu.size())
    {
        auto now = qu.front();
        qu.pop();
        for (int next : graph[now])
        {
            if (observe_dists[next] != -1 || dists[next] != -1)
            {
                continue;
            }

            dists[next] = dists[now] + 1;
            qu.push(next);
        }
    }

    if (dists[N - 1] == -1)
    {
        cout << "No" << endl;
        return 0;
    }

    cout << "Yes" << endl;
    cout << dists[N - 1] << endl;

    return 0;
}