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

#ifdef genshin
#include <experimental/iterator>
#endif
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using uint = unsigned int;
const double EPS = 1e-8;
const int INF = 0x3F3F3F3F;
const ll LINF = 46 * ll(1e17);
const int MOD = 1e9 + 7;
const int maxn = 1e5 + 25;

namespace bridge_cc {
    vector<int> tim, low;
    stack<int, vector<int>> st;
    int t, bcc_id;
    void dfs(int u, int p, const vector<vector<pair<int, int>>> &edge, vector<int> &pa) {
        tim[u] = low[u] = t++;
        st.push(u);
        for (const auto &[v, id] : edge[u]) {
            if (id == p)
                continue;
            if (tim[v])
                low[u] = min(low[u], tim[v]);
            else {
                dfs(v, id, edge, pa);
                if (low[v] > tim[u]) {
                    int x;
                    do {
                        pa[x = st.top()] = bcc_id;
                        st.pop();
                    } while (x != v);
                    bcc_id++;
                }
                else 
                    low[u] = min(low[u], low[v]);
            }
        }
    }
    vector<int> solve(const vector<vector<pair<int, int>>> &edge) {
        int n = edge.size();
        tim.resize(n);
        low.resize(n);
        t = bcc_id = 1;
        vector<int> pa(n);

        for (int i = 0; i < n; i++) {
            if (!tim[i]) {
                dfs(i, -1, edge, pa);
                while (!st.empty()) {
                    pa[st.top()] = bcc_id;
                    st.pop();
                }
                bcc_id++;
            }
        }
        return pa;
    }
};

signed main() { ios::sync_with_stdio(0); cin.tie(0);
    int n, m;
    cin >> n >> m;
    vector<pair<int, int>> edges(m);
    vector<vector<pair<int, int>>> edge(n);
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        edge[u].push_back({v, i});
        edge[v].push_back({u, i});
        edges[i] = {u, v};
    }
    auto pa = bridge_cc::solve(edge);    

    int t = *max_element(pa.begin(), pa.end());
    vector<vector<pair<int, int>>> nw_edge(t + 1);
    vector<vector<pair<int, int>>> eve(t + 1);
    map<pair<int, int>, pair<int, int>> ori;

    for (int i = 0; i < m; i++) {
        auto [u, v] = edges[i];
        auto [a, b] = edges[i];
        u = pa[u];
        v = pa[v];
        if (u == v)
            continue;
        nw_edge[u].push_back({v, i});
        nw_edge[v].push_back({u, i + m});
        ori[{u, v}] = {a, b};
        ori[{v, u}] = {b, a};
    }

    int k;
    cin >> k;
    for (int i = 0; i < k; i++) {
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        a = pa[a];
        b = pa[b];
        eve[a].push_back({i, 1});
        eve[b].push_back({i, -1});
    }

    vector<bool> vis(t + 1);
    bool ok = true;
    vector<pair<int, int>> ans;
    vector<map<int, int>> cnt(t + 1);
    function<map<int, int>(int)> dfs = [&] (int u) {
        vis[u] = true;
        map<int, int> has;
        for (const auto &[tar, dir] : eve[u]) {
            if (has.count(tar)) {
                cnt[u][has[tar]]--;
                has.erase(tar);
            }
            else {
                has[tar] = dir;
                cnt[u][has[tar]]++;
            }
        }
        for (const auto &[v, i] : nw_edge[u]) {
            if (vis[v])
                continue;
            auto owo = dfs(v);

            for (auto &[x, y] : cnt[v])
                cnt[u][x] += y;

            if (has.size() < owo.size())
                swap(has, owo);

            for (const auto &[tar, dir]: owo) {
                if (has.count(tar)) {
                    cnt[u][1]--;
                    cnt[u][-1]--;
                    has.erase(tar);
                }
                else {
                    has[tar] = dir;
                }
            }
            auto [a, b] = ori[{u, v}];
            if (cnt[v][-1] > 0 && cnt[v][1] > 0)
                ok = false;
            if (cnt[v][1] > 0)
                swap(a, b);
            ans.push_back({a, b});
        }
        return has;
    };
    for (int i = 1; i <= t; i++)
        if (!vis[i])
            dfs(i);

    if (!ok) {
        cout << "No\n";
        return 0;
    }

    vector<int> tim(n);
    int num = 1;
    function<void(int)> solve = [&] (int u) {
        tim[u] = num++;
        for (const auto &[v, i] : edge[u]) {
            if (pa[v] != pa[u])
                continue;
            if (tim[v] && tim[v] < tim[u])
                continue;
            if (tim[v]) {
                ans.push_back({v, u});
            }
            else {
                solve(v);
                ans.push_back({u, v});
            }
        }
    };
    for (int i = 0; i < n; i++)
        if (!tim[i])
            solve(i);

    cout << "Yes\n";
    for (const auto &[a, b] : ans)
        cout << a + 1 << ' ' << b + 1 << '\n';
}