#include <iostream>
#include <algorithm>
#include <numeric> // std::gcd

using namespace std;

int gcd(int a, int b) {
	// Find Minimum of a and b
    int res = min(a, b);

  	// Testing divisiblity with all numbers starting from
	// min(a, b) to 1

    while (res > 1) {

        // If any number divide both a and b, so we
        // got the answer
        if (a % res == 0 && b % res == 0)
            break;
        res--;
    }
	return res;
}


// Intervallum struktúra a "rossz" sávok kezelésére
struct Interval {
    long long start;
    long long end;
    bool empty;

    Interval() : start(0), end(-1), empty(true) {}
    Interval(long long s, long long e) : start(s), end(e), empty(false) {
        if (start > end) empty = true;
    }
};

// Kiszámolja azt az intervallumot [0, dim-1]-en belül,
// ahonnan NEM lehet 'step' nagyságút lépni (mert lelépnénk a tábláról).
// Matematikailag: x + step >= dim ÉS x - step < 0
Interval getBadInterval(long long dim, long long step) {
    long long s = max(0LL, dim - step);
    long long e = min(dim - 1, step - 1);
    return Interval(s, e);
}

// Két intervallum metszete
Interval intersect(Interval a, Interval b) {
    if (a.empty || b.empty) return Interval();
    return Interval(max(a.start, b.start), min(a.end, b.end));
}

void solve() {
    long long N, M, H, W;
    if (!(cin >> N >> M >> H >> W)) return;

    // 1. ALAP KIVÉTELEK
    // Ha 1x1-es a tábla, minden mezõ (az az egy) elérve.
    if (N == 1 && M == 1) {
        cout << "YES" << endl;
        return;
    }
    // Ha a tábla 1 dimenziós, de nem 1x1, és a lépések >= 1, akkor lehetetlen.
    // (Mivel a feladat szerint H, W >= 1, nem tudunk "helyben maradni" az 1 széles dimenzióban)
    if (N == 1 || M == 1) {
        cout << "NO" << endl;
        return;
    }

    // 2. MATEMATIKAI FELTÉTELEK
    // Paritás: W+H összegnek páratlannak kell lennie (hogy színt váltson).
    if ((W + H) % 2 == 0) {
        cout << "NO" << endl;
        return;
    }
    // LNKO: Relatív prímeknek kell lenniük.
    if (gcd(W, H) > 1) {
        cout << "NO" << endl;
        return;
    }

    // 3. GEOMETRIAI BLOKKOK (IZOLÁLT MEZÕK)
    // bx_w: Azok az x koordináták, ahonnan nem lehet W-t lépni x-irányban.
    Interval bx_w = getBadInterval(N, W);
    Interval bx_h = getBadInterval(N, H);
    Interval by_w = getBadInterval(M, W);
    Interval by_h = getBadInterval(M, H);

    // Kétféle lépés van:
    // Type 1: dx = W, dy = H (tiltva, ha x in bx_w VAGY y in by_h)
    // Type 2: dx = H, dy = W (tiltva, ha x in bx_h VAGY y in by_w)

    // Akkor van baj, ha létezik olyan (x, y) mezõ, ahonnan se Type 1, se Type 2 nem lehetséges.
    // Halmazelméletileg: (Zone1) metszet (Zone2) != üres.
    // Zone1 = (bx_w sorok) U (by_h oszlopok)
    // Zone2 = (bx_h sorok) U (by_w oszlopok)
    // A metszet 4 részbõl állhat:

    bool isolated = false;

    // 1. eset: x mindkét irányú ugráshoz rossz sávban van
    if (!intersect(bx_w, bx_h).empty) isolated = true;

    // 2. eset: y mindkét irányú ugráshoz rossz sávban van
    if (!intersect(by_w, by_h).empty) isolated = true;

    // 3. eset: x rossz a Type 1-hez, y rossz a Type 2-höz (keresztmetszet)
    if (!bx_w.empty && !by_w.empty) isolated = true;

    // 4. eset: y rossz a Type 1-hez, x rossz a Type 2-höz (keresztmetszet)
    if (!bx_h.empty && !by_h.empty) isolated = true;

    if (isolated) {
        cout << "NO" << endl;
        return;
    }

    // 4. KÉNYSZERPÁLYÁK (NARROW STRIP)
    // Ha az egyik dimenzió túl kicsi egy bizonyos lépéshez, kénytelenek vagyunk
    // a másik típusú lépést használni. Ha az a lépés a másik dimenzióban > 1,
    // akkor átugrunk sorokat/oszlopokat.

    // Ha N <= W, akkor x-ben nem léphetünk W-t. Csak Type 2 (dx=H, dy=W) maradt.
    // Ekkor y mindig W-vel változik. Ha W > 1, nem érünk el mindent.
    if (N <= W && W > 1) {
        cout << "NO" << endl;
        return;
    }
    // Ha N <= H, akkor x-ben nem léphetünk H-t. Csak Type 1 (dx=W, dy=H) maradt.
    // Ekkor y mindig H-val változik. Ha H > 1, nem érünk el mindent.
    if (N <= H && H > 1) {
        cout << "NO" << endl;
        return;
    }
    // Ugyanez M dimenzióra:
    if (M <= W && W > 1) {
        cout << "NO" << endl;
        return;
    }
    if (M <= H && H > 1) {
        cout << "NO" << endl;
        return;
    }

    cout << "YES" << endl;
}

int main() {
    // Gyors I/O beállítása
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int T;
    if (cin >> T) {
        while (T--) {
            solve();
        }
    }
    return 0;
}