use std::str::FromStr;
use std::io::prelude::*;

trait FromFragment: Sized {
    fn from_fragment(s: &str) -> Result<Self, String>;
}

impl FromFragment for String {
    fn from_fragment(s: &str) -> Result<String, String> { Ok(s.to_string()) }
}

// impl FromFragment for bool

macro_rules! impl_from_fragment {
    ( $( $t:ty )* ) => { $(
        impl FromFragment for $t {
            fn from_fragment(s: &str) -> Result<$t, String> {
                <$t>::from_str(s).map_err(|_| {
                    format!("cannot parse \"{}\" as {}", s, stringify!($t))
                })
            }
        }
    )* };
}

impl_from_fragment!(f64 isize i8 i16 i32 i64 usize u8 u16 u32 u64);

trait FromLine: Sized {
    fn from_line(line: &str) -> Result<Self, String>;
}

impl<T: FromFragment> FromLine for T {
    fn from_line(line: &str) -> Result<T, String> {
        T::from_fragment(line.trim_right_matches('\n'))
    }
}

impl<T: FromFragment> FromLine for Vec<T> {
    fn from_line(line: &str) -> Result<Vec<T>, String> {
        let mut result = Vec::new();
        for fragment in line.trim_right_matches('\n').split_whitespace() {
            match T::from_fragment(fragment) {
                Ok(v) => result.push(v),
                Err(msg) => {
                    return Err(format!(
                        "fragment {} of line \"{}\": {}",
                        result.len() + 1, line, msg
                    ))
                }
            }
        }
        Ok(result)
    }
}

macro_rules! impl_from_line_for_tuples {
    ($t:ident $var:ident $count:expr) => ();
    ($t:ident $var:ident $count:expr, $($inner_t:ident $inner_var:ident $inner_count:expr),*) => {
        impl <$t: FromFragment + std::fmt::Display, $($inner_t: FromFragment + std::fmt::Display),*> FromLine for ($t, $($inner_t),*) {
            fn from_line(line: &str) -> Result<( $t, $($inner_t),*), String> {
                let fragments: Vec<&str> =
                    line.trim_right_matches('\n').split_whitespace().collect();
                if fragments.len() != $count {
                    return Err(format!(
                        "line \"{}\" has {} fragments, expected {}",
                        line, fragments.len(), $count
                    ));
                }

                let mut iter = fragments.iter();
                let mut n = 1;
                let $var = <$t>::from_fragment(iter.next().unwrap())
                    .map_err(|msg| {
                        format!("fragment {} of line \"{}\": {}", n, line, msg)
                    })?;
                n += 1;
                $(
                    let $inner_var =
                        <$inner_t>::from_fragment(iter.next().unwrap())
                        .map_err(|msg| {
                            format!("fragment {} of line \"{}\": {}",
                                    n, line, msg)
                        })?;
                    n += 1;
                )*
                Ok(( $var, $($inner_var),* ))
            }
        }
        impl_from_line_for_tuples!($($inner_t $inner_var $inner_count),*);
    }
}

impl_from_line_for_tuples!(T4 x4 4, T3 x3 3, T2 x2 2, T1 x1 1);

macro_rules! read {
    // Discard a line
    (_) => {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
    };

    // Get a FromLine
    ( $pat:pat = $t:ty ) => {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        let $pat = <$t>::from_line(&line).unwrap();
    };

    // Get FromFragment's
    ( $( $pat:pat = $t:ty ),* ) => {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();

        let mut iter = line.split_whitespace();
        let mut n = 1;
        $(
            let fragment = iter.next().unwrap_or_else(|| {
                panic!(
                    "line \"{}\" has only {} fragment(s), more fragments needed",
                    line, n-1
                )
            });
            let $pat = <$t>::from_fragment(fragment).unwrap_or_else(|msg| {
                panic!("fragment {} of line \"{}\": {}", n, line, msg)
            });
            n += 1;
        )*

        if let Some(fragment) = iter.next() {
            panic!(
                "line \"{}\" not exhasted: only {} fragments read, \
                 leaving the next fragment \"{}\"",
                line, n-1, fragment
            );
        }
    };
}

macro_rules! read_n {
    // Get FromLine's
    ( $( $pat:pat = $t:ty ),* ) => {
        $(
            read!($pat = $t);
        )*
    }
}

macro_rules! read_loop {
    ( $pat:pat = $t:ty; $block:block ) => {
        let stdin = std::io::stdin();
        for line in stdin.lock().lines() {
            let line = line.expect("read from stdin failed");
            let $pat = <$t>::from_line(&line).unwrap();
            $block
        }
    }
}

use std::collections::HashSet;

fn gcd(a: i64, b: i64) -> i64 {
    if a == 0 { b } else { gcd(b%a, a) }
}

fn solve((stock, demand, threshold, supply): (i64, i64, i64, i64)) -> bool {
    assert!(stock >= demand && supply >= demand && demand > threshold);
    let g = gcd(demand, supply);
    demand - g + stock%g <= threshold
}

fn main() {
    read!(_);
    read_loop!((stock, demand, threshold, supply) = (i64, i64, i64, i64); {
        let ans = if stock < demand {
            false
        } else if supply < demand {
            false
        } else if demand <= threshold {
            true
        } else {
            solve((stock, demand, threshold, supply))
        };
        let out = if ans { "Yes" } else { "No" };
        println!("{}", out);
    });
}

Measured memory_bytes: 4352