#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 = 50000 + 10, M = 1e5 + 10;
bool ans[N];
struct E {
  int u, v, a, b;
} e[M];

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, a, b;
};
vector<Node> stk;
int p[N], rk[N], maxa[N], maxb[N]; 
int top = 0;
int find(int x) {
    if (p[x] != x) return find(p[x]);
    return p[x];
}

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

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

void init() {
  stk.clear();
  for(int i = 0; i < N; i++) p[i] = i, maxa[i] = maxb[i] = -1, rk[i] = 0;
}


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);
  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;

    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;
      while(j < l && e[j].b <= b) {
        merge(e[j].u, e[j].v, e[j].a, e[j].b);
        j++;
      }
      
      //处理当前分块
      top = 0;
      for(int o = l; o <= r; o++) {
        if(e[o].a <= a && e[o].b <= b) {
          merge(e[o].u, e[o].v, e[o].a, e[o].b);
        }
      }
      
      int fau = find(u), fav = find(v);
      if(fau == fav && maxa[fau] == a && maxb[fau] == b) {
        ans[idx] = true;
      }
      undo();
    }
  }
  
  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;
}