// cf bits/extc++.h nonsense
#ifdef ONLINE_JUDGE
#define _EXT_CODECVT_SPECIALIZATIONS_H 1
#define _EXT_ENC_FILEBUF_H 1
#endif
#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                              \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]: "; \
    dbgh(__VA_ARGS__)
#else
#define dbg(...)
#define cerr   \
    if (false) \
    cerr
#endif

using ll = long long;

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

inline void init_io() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
}

template <typename T>
vector<T> iota(int n, const T& x) {
    vector<T> arr(n);
    iota(begin(arr), end(arr), x);
    return arr;
}

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

template <typename T>
int c_lb(const vector<T>& arr, const T& x) {
    return int(lower_bound(begin(arr), end(arr), x) - begin(arr));
}

template <typename T>
int c_ub(const vector<T>& arr, const T& x) {
    return int(upper_bound(begin(arr), end(arr), x) - begin(arr));
}

template <typename T>
T reversed(T arr) {
    reverse(begin(arr), end(arr));
    return arr;
}

template <typename T>
T sorted(T arr) {
    sort(begin(arr), end(arr));
    return arr;
}

template <typename T>
bool on(T mask, int bit) {
    return (mask >> bit) & 1;
}

template <typename A, typename B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
    return out << "(" << p.first << ", " << p.second << ")";
}

long kv;
map<array<long, 3>, bool> dp0_memo;
map<array<long, 4>, bool> dp_memo;

bool dp0(long x1, long x2, long f2) {
    dbg(x1, x2, f2);
    if (x1 < 0) {
        assert(x2 >= 0);
        return false;
    }
    if (x2 <= 0) {
        return true;
    }
    long a1 = max(long(0), x1 - kv * f2), a2 = x2;

    if (x1 - kv * f2 < 0) {
        long t = clamp((kv * f2 - x1) / (kv - a2), long(1), f2);
        return dp0(x1 - t * x2, x2, f2 - t);
    }

    assert(a1 < kv && a2 < kv);

    if (x1 - kv * f2 + f2 * (kv - a2) >= x2) {
        return true;
    } else if (!f2) {
        assert(x1 < x2);
        return false;
    }

    auto [it, inserted] = dp_memo.insert({{x1, x2, f2}, false});
    bool& ans = it->second;
    if (!inserted) {
        return ans;
    }

    ans = ans || dp0(x1 - x2, x2, f2 - 1);
    if (a1) {
        ans = ans || dp0(x1 - (x2 - a1), x2 - a1, f2);
    }

    return ans;
}

bool dp(long x1, long f1, long x2, long f2) {
    assert(x1 > 0);
    if (x2 <= 0) {
        return true;
    }
    long a1 = max(long(0), x1 - kv * f2), a2 = max(long(0), x2 - kv * f1);
    dbg(x1, f1, x2, f2, a1, a2);

    if (a1 >= a2 && a1 >= kv) {
        // because I just always attack
        return true;
    } else if (a2 >= kv || !f2) {
        // a2 >= kv forces me to attack cuz otherwise I just lose for no good
        // reason !f2 just forces me to
        return !dp(x2 - a1, f2, x1, f1);
    }

    assert(a1 < kv && a2 < kv);
    if (!f1) {
        return dp0(x1, x2, f2);
    }

    if (!a1) {
        return !dp(x2, f2 - 1, x1, f1);
    }

    if (a1 >= a2 && a1 > 0) {
        // I jump then insta win
        return true;
    }

    if (f2 >= 1 && x1 >= kv * f2 && dp(x1 + f2 * (kv - a2), f1, x2, 0)) {
        // short circuiting max jumping
        return true;
    }

    assert(0 < a1 && a1 < kv && 0 < a2 && a2 < kv);
    f1 = min(f1, kv);
    f2 = min(f2, kv);
    auto [it, inserted] = dp_memo.insert({{x1, f1, x2, f2}, false});
    bool& ans = it->second;
    if (!inserted) {
        return ans;
    }

    ans = ans || !dp(x2, f2 - 1, x1, f1);
    ans = ans || !dp(x2 - a1, f2, x1, f1);

    return ans;
}

void solve() {
    long x1, f1, x2, f2;
    cin >> x1 >> f1 >> x2 >> f2;

    long rf2 = x1 / kv, rf1 = x2 / kv, sub = min(f2 - rf2, f1 - rf1);
    if (sub > 0) {
        f1 -= sub;
        f2 -= sub;
    }
    dbg(x1, f1, x2, f2);

    if (dp(x1, f1, x2, f2)) {
        cout << "YES" << endl;
    } else {
        cout << "NO" << endl;
    }
}

int main() {
    init_io();
    int q;
    cin >> kv >> q;
    while (q--) {
        solve();
    }
}