#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <list>
#include<fstream>
#include <bitset>

using namespace std;  
using ll = long long;
using ull = unsigned long long;
#define pb push_back
#define P pair
#define V vector
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define FFOR(i, a, b) for (int i = a; i <= b; ++i)

template <typename U, typename T, class Cmp>
ostream& operator <<(ostream& out, const map<U, T, Cmp>& a) {
  out << "{"; bool first = true;
  for (auto& p : a) { out << (first ? "" : ", "); out << p.first << ":" << p.second; first = 0;} out << "}";
  return out;
}

template <typename T>
ostream& operator <<(ostream& out, const vector<T>& a) {
  out << "["; bool first = true;
  for (auto v : a) { out << (first ? "" : ", "); out << v; first = 0;} 
  out << "]";
  return out;
}

const int N = 1e5 + 10;
bool ans[N];
struct E {
  int u, v, a, b;
} e[N];

struct Q {
  int u, v, a, b, i;
  bool operator< (const Q& other) {
    return b < other.b;
  }
} q[N];

bool comp1(E& e1, E& e2) {
  return e1.a < e2.a;
}

bool comp2(E& e1, E& e2) {
  return e1.b < e2.b;
}



//DSU
struct Node {
    int fax, fay, w;
};
vector<Node> stk;
int p[N], rk[N]; 
int find(int x) {
    if (p[x] != x) return find(p[x]);
    return p[x];
}

bool merge(int u, int v) {
  int fax = find(u), fay = find(v);
  if(rk[fax] > rk[fay]) {
    swap(fax, fay);
  }
  if(fax != fay) {
    p[fax] = fay;
    stk.push_back({fax, fay, rk[fax] == rk[fay]});
    if(rk[fay] == rk[fax]) rk[fay]++;
    return true;
  }
  return false;
}

void undo(int k) {
  while(k--) {
    auto pa = stk.back(); stk.pop_back();
    int fax = pa.fax, fay = pa.fay, w = pa.w;
    p[fax] = fax;
    rk[fay] -= w;
  }
}

void init() {
  stk.clear();
  memset(rk, 0, sizeof rk);
  for(int i = 0; i < N; i++) p[i] = i;
}


void solve() {
  int n, m;
  scanf("%d%d", &n, &m);

  for(int i = 0; i < m; i++) {
    int u, v, a, b;
    scanf("%d%d%d%d", &u, &v, &a, &b);
    e[i] = {u, v, a, b};
  }
  sort(e, e + m, comp1);

  int k;
  scanf("%d", &k);
  for(int i = 0; i < k; i++) {
    int u, v, a, b;
    scanf("%d%d%d%d", &u, &v, &a, &b);
    q[i] = {u, v, a, b, i};
  }
  sort(q, q + k);
  
  //分块范围初始化
  int s =  sqrt(m * log2(n));
  vector<pair<int, int>> blocks;
  for(int i = 0; i < m; i += s) {
    blocks.push_back({i, min(m - 1, i + s - 1)});
  }

  vector<vector<int>> T(blocks.size());
  for(int i = 0; i < k; i++) {
    int j = 0;
    while(j < blocks.size() && e[blocks[j].second].a <= q[i].a) j++;
    T[min(j, (int)(T.size() - 1))].push_back(i);
  }
  
  //for(int i = 0; i < T.size(); i++) {
      //cout << i << "  " << blocks[i].first << "  " << blocks[i].second << T[i] << endl;
  //}
  
  for(int i = 0; i < blocks.size(); i++) {
    int l = blocks[i].first, r = blocks[i].second;
    
    init();
    sort(e, e + l, comp2);
    int j = 0;
    int maxa = -1, maxb = -1;

    for(int x : T[i]) {
      int u = q[x].u, v = q[x].v, a = q[x].a, b = q[x].b, idx = q[x].i;
      bool founda = false, foundb = false;
      while(j < l && e[j].b <= b) {
        merge(e[j].u, e[j].v);
        maxa = max(maxa, e[j].a);
        maxb = max(maxb, e[j].b);
        j++;
      }
      
      //处理当前分块
      int ops = 0;
      for(int o = l; o <= r; o++) {
        if(e[o].a <= a && e[o].b <= b) {
          if(e[o].a == a) founda = true;
          if(e[o].b == b) foundb = true;
          if(merge(e[o].u, e[o].v)) {
            ops++;
          }
        }
      }
      if(maxa == a) founda = true;
      if(maxb == b) foundb = true;
      if(founda && foundb && find(u) == find(v)) {
        ans[idx] = true;
      }
      undo(ops);
    }
  }
  
  for(int i = 0; i < k; i++) {
    if(ans[i]) printf("Yes\n");
    else printf("No\n");
  }
}

int main() {
  int t = 1;
  while(t--) {
    solve();
  }
  return 0;
}