#include <bits/stdc++.h>
template <typename T>
inline bool chkmax(T &a, T b) {
  return a < b ? a = b, true : false;
}
template <typename T>
inline bool chkmin(T &a, T b) {
  return a > b ? a = b, true : false;
}
template <typename T>
void read(T &first) {
  int f = 1;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar()) {
    if (ch == '-') f = -1;
  }
  for (first = 0; isdigit(ch); ch = getchar()) {
    first = first * 10 + ch - '0';
  }
  first *= f;
}
const int MAXN = 1e5 + 5, MAXM = 1e5 + 5;
struct Edge {
  int v, next;
  Edge() {}
  Edge(int v_, int next_) : v(v_), next(next_) {}
};
int N, M, Q;
int tote, head[MAXN];
Edge edge[MAXM * 2 + 5];
int fa[MAXN], dep[MAXN], size[MAXN], hson[MAXN], top[MAXN];
int curtid, tid[MAXN];
int sum[MAXN];
int dfsclock, dfn[MAXN], low[MAXN];
std::pair<int, int> st[MAXN];
int sttop;
inline void addEdge(int u, int v) {
  edge[++tote] = Edge(v, head[u]);
  head[u] = tote;
}
void dfs1(int u) {
  tid[u] = curtid;
  size[u] = 1;
  for (int i = head[u]; i; i = edge[i].next) {
    int v = edge[i].v;
    if (!tid[v]) {
      fa[v] = u;
      dep[v] = dep[u] + 1;
      dfs1(v);
      size[u] += size[v];
      if (size[v] > size[hson[u]]) hson[u] = v;
    }
  }
}
void dfs2(int u) {
  if (hson[u]) {
    top[hson[u]] = top[u];
    dfs2(hson[u]);
    for (int i = head[u]; i; i = edge[i].next) {
      int v = edge[i].v;
      if (fa[v] == u && v != hson[u]) {
        top[v] = v;
        dfs2(v);
      }
    }
  }
}
inline long long getLCA(int u, int v) {
  while (top[u] != top[v]) {
    if (dep[top[u]] > dep[top[v]])
      u = fa[top[u]];
    else
      v = fa[top[v]];
  }
  return dep[u] > dep[v] ? v : u;
}
void tarjan(int u) {
  dfn[u] = low[u] = ++dfsclock;
  for (int i = head[u]; i; i = edge[i].next) {
    int v = edge[i].v;
    std::pair<int, int> cur = std::make_pair(u, v);
    if (fa[v] == u) {
      st[++sttop] = cur;
      tarjan(v);
      chkmin(low[u], low[v]);
      if (low[v] >= dfn[u]) {
        int f = 0;
        for (int j = sttop;; --j) {
          if ((dep[st[j].first] & 1) == (dep[st[j].second] & 1)) {
            f = 1;
            break;
          }
          if (st[j] == cur) break;
        }
        do {
          if (st[sttop].first != u) sum[st[sttop].first] = f;
          if (st[sttop].second != u) sum[st[sttop].second] = f;
        } while (st[sttop--] != cur);
      }
    } else if (dfn[v] < dfn[u] && fa[u] != v) {
      chkmin(low[u], dfn[v]);
      st[++sttop] = cur;
    }
  }
}
void getsum(int u) {
  sum[u] += sum[fa[u]];
  for (int i = head[u]; i; i = edge[i].next) {
    int v = edge[i].v;
    if (fa[v] == u) getsum(v);
  }
}
bool haveOddPath(int u, int v) {
  if (tid[u] != tid[v]) return false;
  if ((dep[u] & 1) != (dep[v] & 1)) return true;
  int lca = getLCA(u, v);
  return sum[u] + sum[v] - (sum[lca] << 1) > 0;
}
void input() {
  read(N);
  read(M);
  for (int i = 1; i <= M; ++i) {
    int u, v;
    read(u);
    read(v);
    addEdge(u, v);
    addEdge(v, u);
  }
  read(Q);
}
void solve() {
  for (int i = 1; i <= N; ++i) {
    if (!tid[i]) {
      ++curtid;
      dep[i] = 1;
      dfs1(i);
      top[i] = i;
      dfs2(i);
      dfsclock = 0;
      tarjan(i);
      getsum(i);
    }
  }
  while (Q--) {
    int u, v;
    read(u);
    read(v);
    puts(haveOddPath(u, v) ? "Yes" : "No");
  }
}
int main() {
  input();
  solve();
  return 0;
}
