#include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define se second
#define ll long long
#define pb push_back 
#define SZ(a) ((int)(a.size()))
#define rep(i,a,b) for(int i=a;i<b;i++)
#define mp make_pair

using namespace std;
const int N=2e6+10;
const int mod=998244353;
// unordered_map<pii,int>has;  
map<pii,int>has;
// ll hhash(int u,int v){
//     return u*1e9+v;
// }
// unordered_map<pii,int>link;
struct Edge{
    int u,v,id;
};
// vector<pii> ans;
set<pii>ans;  //用set更方便！！！
Edge ed[N];
namespace Tarjan{
    int e[N<<1],ne[N<<1],h[N],idx;
    int h2[N];
    // unordered_map<int,int>has;

    int sz[N];
    void add(int a,int b){
        e[idx]=b,ne[idx]=h[a],h[a]=idx++;
    }
    void add2(int a,int b){
        e[idx]=b,ne[idx]=h2[a],h2[a]=idx++;

    }
    int isbridge[N];
    int dfn[N],low[N],timestamp;
    // int fa[N];
    int id[N],dcc_cnt;
    int stk[N],top;
    void tarjan(int u,int from){
        dfn[u]=low[u]=++timestamp;
        stk[++top]=u;
        for(int i=h[u];~i;i=ne[i]){
            int j=e[i];
            if(!dfn[j]){
                // fa[j]=u;
                tarjan(j,i);
                low[u]=min(low[j],low[u]);

                if(low[j]>dfn[u]){
                    // 是桥
                    isbridge[i]=isbridge[i^1]=1;
                }
            }
            else if(i!=(from^1)){
                //则找到强连通分量
                low[u]=min(low[u],dfn[j]);
            }

        }
        
        // if(dfn[u]==low[u]){
        //     ++dcc_cnt;
        //     // int sz=0;
        //     int y=u;
            // do{
            //     // sz++;
            //     sz[dcc_cnt]++;   
            //     if(y!=stk[top]){
            //         // if(y==6990||stk[top]==6990)cout<<" !!!  "<<y<<" "<<stk[u]<<endl;
            //         // 栈顶不一定和u相连！！！
            //         // ans.insert(mp(y,stk[top]));//出栈一定是dfs 联通序,仍然有许多边没有记录！！！
            //         // has[mp(y,stk[top])]=1;

            //     }
            //     // cout<<y<<"   circle  "<<stk[top]<<endl;
            //     y=stk[top--];
            //     id[y]=dcc_cnt;
            // }while(y!=u);
          

        // }

    }
    int vis[N<<1];
// 确定一个连通分量内
void getiner(int u){
    id[u]=dcc_cnt;
    // cout<<u<<"  u"<<endl;
    for(int i=h[u];~i;i=ne[i]){
        int j=e[i];
        if(isbridge[i])continue;
        if(!vis[i]&&!vis[i^1]){
            ans.insert(mp(u,j));
            vis[i]=vis[i^1]=1;
        }
        
        if(id[j])continue;
        getiner(j);
        

    }

}

}

using namespace Tarjan;
namespace LCA{
    int dep[N],fa[N][21];

    void init(int u,int ff){

        #ifdef deb
        cout<<"u  ff  "<<u<<"  "<<ff<<endl;
        #endif
        dep[u]=dep[ff]+1;
        fa[u][0]=ff;
        for(int i=1;i<=20;i++){
            fa[u][i]=fa[fa[u][i-1]][i-1];
        }
        for(int i=h2[u];~i;i=ne[i]){
            int j=e[i];
            if(j==ff)continue;
            init(j,u);
        }
    }
    int lca(int u,int v){
        if(dep[u]<dep[v])swap(u,v);
        for(int i=20;i>=0;i--){
            if(dep[fa[u][i]]>=dep[v])u=fa[u][i];
        }
        if(dep[u]==dep[v])return u;
        for(int i=20;i>=0;i--){
            if(fa[u][i]!=fa[v][i])u=fa[u][i],v=fa[v][i];
        }
        return fa[u][0];
    }
}
int uptree[N],downtree[N];


using namespace LCA;
// 按照题解的差分方式,前缀时要先子树后自己
int dire[N];

bool dfs1(int u,int ff,int from){
    // uptree[u]=uptree[ff]+uptree[u];
    for(int i=h2[u];~i;i=ne[i]){
        int j=e[i];if(j==ff)continue;
        if(!dfs1(j,u,i))return false;
        uptree[u]+=uptree[j];
    }
    if(from==-1)return true;
    // cout<<u<<"   "<<uptree[u]<<"   "<<downtree[u]<<"   tree"<<endl;
    if(uptree[u]>0&&downtree[u]>0){  //指的是该节点上面的边 (父边)
        return false;
    }
    if(uptree[u]>0){
        // cout<<u<<"     ->  "<<ff<<"   "<<id[4]<<endl;
        has[mp(u,ff)]=1;

        // 怎么映射定向？？？
        // 
        // 按照给出的顺序

        // 直接记录点对比记录边的朝向更加方便！！！！
        // dire[has[from]]=0;
        // dire[has[from]^1]=1;// 同向

        //向上 
    }
    else {
        has[mp(ff,u)]=1; //判断方向时直接根据id[u],id[v]确定，不用映射

        // dire[from]=dire[from^1]=2;//向下
        // dire[has[from]]=1;dire[has[from]^1]=0;
    }
    return true;
}



// void getans(int u,int ff,int from){
//     if(ff){
//         if(uptree[u]-uptree[ff]>0){
//             dire[has[from]]=0;  //异乡
//             dire[has[from]^1]=1;   //同向
//             //代表向上
//         }
//         else {
//             dire[has[from]]=dire[has[from]^1]=2;
//         }
//     }
//     for(int i=h2[u];~i;i=ne[i]){
//         if(i==from^1)continue;
//         int j=e[i];
//         getans(j,u,i);
//     }
// }

signed main(){
    int n,m;
    // freopen("C:/Users/lenovo/Desktop/div1/day5/007.in","r",stdin);
    cin>>n>>m;
    // cout<<n<<"  "<<n<<endl;
    memset(h,-1,sizeof h);
    memset(h2,-1,sizeof h2);
    for(int i=1;i<=m;i++){
        int u,v;
        cin>>u>>v;
        // ed[i]=mp(u,v);
        ed[i]={u,v,idx};
        
        add(u,v),add(v,u);
    }
    tarjan(1,1); 
    for(int i=1;i<=n;i++){
        
        if(!id[i]){
            ++dcc_cnt;
            getiner(i);
            // cout<<endl;
        }
    }
    
    // cout<<dcc_cnt<<endl;
    // exit(0);
    for(int i=1;i<=m;i++){
        // 给出的是uv
        int u=ed[i].u,v=ed[i].v;
        if(id[u]!=id[v]){
            // cout<<u<<"  uv "<<v<<endl;
            // has[idx]=ed[i].id;
            // has[idx+1]=ed[i].id^1;
            // 连的时候也是先u后v
            add2(id[u],id[v]),add2(id[v],id[u]);
        }
    }
   
    init(1,0);
    // for(int i=1;i<=dcc_cnt;i++){
    //     for(int j=0;j<2;j++){
    //         // cout<<fa[i][j]<<"  "<<i<<"  "<<j<<"  "<<endl;
    //     }
    //     cout<<endl;
    // }
    // cout<<lca(1,2)<<"  !!!"<<endl;
    // exit(0);
    int nn;
    vector<pii> up,down; 
    cin>>nn;
    rep(i,0,nn){
        int u,v;
        cin>>u>>v;
        u=id[u],v=id[v];
        if(u==v)continue;
        // cout<<u<<"   "<<v<<"  aft "<<endl;
        int Lca=lca(u,v);

        if(Lca!=u&&Lca!=v){
            up.pb(mp(u,Lca)),down.pb(mp(Lca,v));
        }
        else if(dep[u]>dep[v]){
            
            up.pb(mp(u,v));

        }
        else{

            /*
9 12 
1 2 
2 3
3 1
2 4
4 5
5 6
4 6
6 8
5 7
3 9
2 9
1 9
5
2 4
2 8
2 7
9 1
9 2

            */
           
            down.pb(mp(u,v));
        }
    }
    // for(auto t:down){
    //     cout<<t.fi<<"  down "<<t.se<<endl;
    // }
    // for()
    // exit(0);
    for(auto t:up){
        int be=t.fi,ed=t.se;
        uptree[be]++,uptree[ed]--;  //边的上面的点的前缀和<0则该边向上
    }
    for(auto t:down){
        int be=t.fi,ed=t.se;
        downtree[ed]++,downtree[be]--;
    }
   
    if(dfs1(1,1,-1)){
        puts("Yes"); 
        // cout<<has[mp(2,1)]<<"    "<<has[mp(1,2)]<<endl;
        // exit(0);
        for(int i=0;i<2*m;i+=2){
            int u=e[i],v=e[i^1]; 
            // if(u==6990||v==6990){
            //     cout<<u<<"  "<<v<<endl;
            //   }
            if(id[u]!=id[v]){
                if(has[mp(id[u],id[v])]){
                    // cout<<u<<"    "<<v<<endl;
                    // cout<<"   !!!!!!!!!"<<endl;
                    ans.insert(mp(u,v));
                }
                else{
                    // ans.em
                    ans.insert(mp(v,u));
                }
            }
           
            // cout<<dire[i]<<"  "<<endl<<endl;
            // if(dire[i]==1){
            //     cout<<e[i^1]<<" "<<e[i]<<endl;
            // }
            // else {
            //     cout<<e[i]<<" "<<e[i^1]<<endl;
            // }
            
        } 
        // for(int i=0;i<2*m;i+=2){
        //       int u=e[i],v=e[i^1];
             
        //     if(ans.find(mp(u,v))==ans.end()&&ans.find(mp(v,u))==ans.end()){
        //         ans.insert(mp(u,v));

        //     }
        // }
        for(auto t:ans){
                
                // cout<<t.fi<<" "<<t.se<<endl;
                cout<<t.fi<<" "<<t.se<<endl;
                // if(t.fi==100)break;

            }

    }
    else{
        puts("No");
        return 0;
    }
    // // for(auto t:down){
    // //     int be=t.fi,ed=t.se;  //从上往下
    // //     if(uptree[fa[ed][0]]-uptree[fa[be][0]]!=0){  //把边变成点才可以这样差分!!!(可以try)
    // //         puts("No");
    // //         return 0;
    // //     }
    // //     else{
    // //         uptree[be]--,uptree[ed]++;
    // //     }
    // // }

    // getans(1,0,-1);
    // puts("Yes");
    // for(int i=0;i<idx;i+=2){
    //     int a=e[i],b=e[i^1];
    //     if(dep[a]<dep[b])swap(a,b);
    //     if(dire[i]==2){
    //         cout<<a<<"  "<<b<<endl;
    //     }
    //     else {
    //         cout<<b<<"  "<<a<<endl;
    //     }
    // }

}