#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using LL = long long;
using pii = pair<int, int>;
#define sz(x) signed(size(x))

void solve() {
    int n, m;
    cin >> n >> m;

    vector<vector<int>> adj(n + 1);
    while (m--) {
        int u, v;
        cin >> u >> v;
        adj[u].emplace_back(v);
        adj[v].emplace_back(u);
    }

    int k;
    cin >> k;
    vector<pii> tgt(k);
    for (auto& [x, y] : tgt)
        cin >> x >> y;

    stack<int> stk;
    vector<int> low(n + 1), dfn(n + 1, -1), bcc(n + 1);
    int timer = 0, lst = 0;
    auto dfs1 = [&](auto& self, int cur, int par) -> void {
        dfn[cur] = low[cur] = timer++;
        stk.emplace(cur);
        for (int nxt : adj[cur]) {
            if (nxt == par) continue;
            if (dfn[nxt] == -1) {
                self(self, nxt, cur);
                low[cur] = min(low[cur], low[nxt]);
            }
            low[cur] = min(low[cur], dfn[nxt]);
        }
        
        if (low[cur] == dfn[cur]) {
            ++lst;
            int top;
            do {
                top = stk.top();
                stk.pop();
                bcc[top] = lst;
            } while (top != cur);
        }

        return;
    };

    dfs1(dfs1, 1, 0);

    vector<pii> ans;
    vector<bool> vis(n + 1);

    set<tuple<int, int, int, int>> st;
    vector<bool> in(n + 1);
    auto dfs2 = [&](auto& self, int cur, int pre) -> void {
        in[cur] = 1;
        vis[cur] = 1;
        for (int nxt : adj[cur]) {
            if (bcc[nxt] != bcc[cur]) {
                st.emplace(bcc[cur], bcc[nxt], cur, nxt);
                st.emplace(bcc[nxt], bcc[cur], nxt, cur);
                continue;
            }
            if (nxt == pre) continue;
            if (in[nxt]) {
                ans.emplace_back(cur, nxt);
                continue;
            }
            if (vis[nxt]) continue;
            ans.emplace_back(cur, nxt);
            self(self, nxt, cur);
        }
        in[cur] = 0;
        return;
    };
            
    for (int i = 1; i <= n; ++i)
        if (!vis[i])
            dfs2(dfs2, i, 0);

    vector<vector<tuple<int, int, int>>> adj2(lst + 1);
    for (const auto& [u, v, x, y] : st)
        adj2[u].emplace_back(v, x, y);
    
    vector par(lst + 1, vector<int>(20));
    vector<int> dep(lst + 1);
    auto dfs3 = [&](auto& self, int cur, int fa) -> void {
        dep[cur] = dep[fa] + 1;
        for (auto& [nxt, x, xx] : adj2[cur]) {
            if (nxt == fa) continue;
            par[nxt][0] = cur;
            self(self, nxt, cur);
        }
    };
    dfs3(dfs3, 1, 0);

    for (int i = 1; i < 20; ++i)
        for (int j = 1; j <= lst; ++j)
            par[j][i] = par[par[j][i - 1]][i - 1];

    auto jump = [&](int& u, int dis) {
        for (int i = 19; i >= 0; --i)
            if (dis - (1 << i) >= 0) {
                u = par[u][i];
                dis -= (1 << i);
            }
    };

    auto find_lca = [&](int u, int v) {
        if (dep[u] < dep[v]) swap(u, v);
        jump(u, dep[u] - dep[v]);
        if (u == v) return u;

        for (int i = 19; i >= 0; --i) 
            if (par[u][i] != par[v][i])
                u = par[u][i], v = par[v][i];

        return par[u][0];
    };

    vector<int> dsu(2 * (lst + 1));
    iota(dsu.begin(), dsu.end(), 0);
    
    auto find = [&](auto& self, int cur) -> int {
        return dsu[cur] == cur ? cur : dsu[cur] = self(self, dsu[cur]);
    };

    auto unit = [&](int u, int v) {
        u = find(find, u);
        v = find(find, v);
        
        dsu[u] = v;
        return;
    };

    vector<int> tag(n + 1);
    for (auto [u, v] : tgt) {
        u = bcc[u], v = bcc[v];
        if (u == v) continue;

        int lca = find_lca(u, v);
        int cur = find(find, 2 * u);
        while (dep[cur / 2] > dep[lca]) {
            tag[cur / 2] += 1;
            unit(cur, 2 * par[cur / 2][0]);
            cur = find(find, cur);
        }

        cur = find(find, 2 * v + 1);
        while (dep[cur / 2] > dep[lca]) {
            tag[cur / 2] += 2;
            unit(cur, 2 * par[cur / 2][0] + 1);
            cur = find(find, cur);
        }
    }

    set<pii> st2;
    for (int i = 1; i <= lst; ++i) {
        if (tag[i] == 3) {
            cout << "No\n";
            return;
        }
        else if (tag[i] == 1)
            st2.emplace(i, par[i][0]);
        else
            st2.emplace(par[i][0], i);
    }

    for (int cur = 1; cur <= lst; ++cur)
        for (auto& [nxt, x, y] : adj2[cur])
            if (st2.count({cur, nxt}))
                ans.emplace_back(x, y);
        

    cout << "Yes\n";
    for (const auto& [u, v] : ans)
        cout << u << ' ' << v << '\n';

    return;
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);
    int t = 1;
    while (t--)
        solve();
    return 0;
}