#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define vi  vector<int>
#define vvi vector<vector<int>>
#define rep(i, st, ed) for(int i = st; i < ed; ++i)
// ************************DEBUG START********************************
#ifndef ONLINE_JUDGE  // if ONLINE_JUDGE is not defined (when compiling on our pc, this is true)
//#define cerr cout  // if you want to print to stdout, uncomment this
#include "myprettyprint.hpp" // include myprettyprint.hpp
#else
#define dbg(...) // else, when defined (most modern CP sites have this defined), define dbg(...).
                 // this basically just would do nothing on seeing dbg() and thus no need to remove dbg() while submitting.
#endif
// ************************DEBUG END**********************************
const int MX_LVL=20;
struct edge{
  int x,y,d;
};
struct tree{
  int N, R;
  vvi G,PAR;
  vi LVL;
  void init(int n, int r){
    N=n; R=r;
    PAR.resize(MX_LVL,vi(N,-1));
    G.resize(N);
    LVL.resize(N,1);
  }
  void add_edge(int x,int y){
    G[x].push_back(y);
    G[y].push_back(x);
  }
  void dfs(int x){
    for(auto y:G[x]){
      if (PAR[0][y]>=0) continue;
      PAR[0][y]=x;
      LVL[y]=LVL[x]+1;
      dfs(y);
    }
  }
  void make_par(){
    PAR[0][R]=R;
    dfs(R);
    rep(i,1,MX_LVL) rep(x,0,N){
      PAR[i][x]=PAR[i-1][PAR[i-1][x]];
    }
  }
  int LCA(int x, int y){
    if (LVL[x]<LVL[y]) swap(x,y);
    int d=LVL[x]-LVL[y];
    rep(i,0,MX_LVL) if(d&(1<<i)){
      x=PAR[i][x];
    }
    if (x==y) return x;
    while (PAR[0][x]!=PAR[0][y]){
      for(int i=MX_LVL-1;i>=0;i--) if(PAR[i][x]!=PAR[i][y]){
        x=PAR[i][x];
        y=PAR[i][y];
      }
    }
    return PAR[0][x];
  }
}TREE;

int V,E,K;
vi ORD,DSCV,PRV;
int now=0;
vi BRG, TREE_NODE;
map<pair<int,int>, int> MAP;
vector<vector<pair<int,int>>> G;
vector<edge> EDGE;

vector<int> v;
int root(int x) {
  if(v[x] == x) return x;
  else return v[x] = root(v[x]);
}
void uf(int x,int y){
  if(root(x) != root(y)) v[root(x)] = root(y);
}
int t_node(int x){
  return TREE_NODE[root(x)];
}

void dfs(int x){
  ORD[x]=++now;
  DSCV[x]=now;
  for(auto p:G[x]){
    int y=p.first, idx=p.second;
    if (y==PRV[x]) continue;
    if (ORD[y]) {
      DSCV[x]=min(DSCV[x],DSCV[y]);
      if (EDGE[idx].d==0) EDGE[idx].d=(y>x)?1:-1; //1이면 더 큰 수로 이동하는 간선
      continue;
    }
    PRV[y]=x;
    dfs(y);
    if (ORD[x]<DSCV[y]) BRG.push_back(idx);
    else {EDGE[idx].d=(y>x)?1:-1; uf(x,y);}
    DSCV[x]=min(DSCV[x],DSCV[y]);
  }
}

void solve(){
  cin >> V >> E;
  G.resize(V); EDGE.resize(E);
  rep(i,0,E){
    int a,b;cin>>a>>b;
    G[a-1].push_back({b-1,i});
    G[b-1].push_back({a-1,i});
    edge e={a-1,b-1,0};
    EDGE[i]=e;
  }
  ORD.resize(V); DSCV.resize(V); PRV.resize(V); v.resize(V);
  rep(i,0,V) v[i]=i;
  dfs(0);
  dbg(BRG);
  rep(i,0,E) dbg(EDGE[i].x,EDGE[i].y,EDGE[i].d);
  dbg(v);

  TREE_NODE.resize(V,-1);
  int tmp=0;
  rep(i,0,V) if(TREE_NODE[root(i)]==-1) TREE_NODE[root(i)]=tmp++;

  int N=BRG.size()+1;
  TREE.init(N,0);
  for(auto i:BRG){
    int x=t_node(EDGE[i].x), y=t_node(EDGE[i].y);
    TREE.add_edge(x,y);
    TREE.add_edge(y,x);
    MAP[{min(x,y),max(x,y)}]=i;
  }
  TREE.make_par();

  int Q;cin>>Q;
  while(Q--){
    int a,b;cin>>a>>b;
    int x=t_node(a-1), y=t_node(b-1);
    if (x==y) continue;
    int z=TREE.LCA(x,y),cur=x,prv;
    while (cur!=z){
      prv=cur;
      cur=TREE.PAR[0][cur];
      //prv->cur
      int idx=MAP[{min(prv,cur),max(prv,cur)}];
      int u=EDGE[idx].x, v=EDGE[idx].y, d;
      d=(t_node(max(u,v))==cur)?1:-1;
      if(EDGE[idx].d==0) EDGE[idx].d=d;
      else if (EDGE[idx].d!=d) {cout << "No\n"; return;}
    }
    cur=y;
    while (cur!=z){
      prv=cur;
      cur=TREE.PAR[0][cur];
      //cur->prv
      int idx=MAP[{min(prv,cur),max(prv,cur)}];
      int u=EDGE[idx].x, v=EDGE[idx].y, d;
      d=(t_node(max(u,v))==prv)?1:-1;
      if(EDGE[idx].d==0) EDGE[idx].d=d;
      else if (EDGE[idx].d!=d) {cout << "No\n"; return;}
    }
  }
  cout << "Yes\n";
  for(auto e:EDGE){
    int x=e.x, y=e.y, d=e.d;
    if(d==1) cout << min(x,y)+1 << ' ' << max(x,y)+1 << '\n';
    else cout << max(x,y)+1 << ' ' << min(x,y)+1 << '\n';
  }
}

int main(){
  cin.tie(nullptr)->sync_with_stdio(false);
	solve();
}