#include <bits/stdc++.h>
using namespace std;
namespace std {
template <class T>
T begin(std::pair<T, T> p) {
  return p.first;
}
template <class T>
T end(std::pair<T, T> p) {
  return p.second;
}
}  // namespace std
template <class Iterator>
std::reverse_iterator<Iterator> make_reverse_iterator(Iterator it) {
  return std::reverse_iterator<Iterator>(it);
}
template <class Range>
std::pair<std::reverse_iterator<decltype(begin(std::declval<Range>()))>,
          std::reverse_iterator<decltype(begin(std::declval<Range>()))>>
make_reverse_range(Range &&r) {
  return std::make_pair(make_reverse_iterator(::begin(r)),
                        make_reverse_iterator(::end(r)));
}
template <class T>
int sign(const T &a) {
  return a == 0 ? 0 : a > 0 ? 1 : -1;
}
template <class T>
inline T min(T a, T b, T c) {
  return min(min(a, b), c);
}
template <class T>
inline T max(T a, T b, T c) {
  return max(max(a, b), c);
}
template <class T>
void Min(T &a, const T &b) {
  a = min(a, b);
}
template <class T>
void Max(T &a, const T &b) {
  a = max(a, b);
}
template <typename T>
void println(const T &t) {
  cout << t << '\n';
}
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
  cout << t << ' ';
  println(rest...);
}
template <typename T>
void print(const T &t) {
  cout << t << ' ';
}
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
  cout << t;
  print(rest...);
}
template <class T>
void scan(T &t) {
  cin >> t;
}
template <class T, class... Args>
void scan(T &a, Args &...rest) {
  cin >> a;
  scan(rest...);
}
using ll = long long;
using ull = unsigned long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pii = pair<int, int>;
using pdd = pair<double, double>;
using pip = pair<int, pii>;
using szt = size_t;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using pli = pair<ll, int>;
using wg = vector<vpii>;
int cas;
const double pi = acos(-1);
ll mod = 1e9 + 7;
template <class T>
inline void add_mod(T &a, const T &b) {
  a += b;
  if (a >= mod) a -= mod;
}
template <class T>
void sub_mod(T &a, const T &b) {
  a -= b;
  if (a < 0) a += mod;
}
auto bo = [](int x) {
  bitset<5> a(x);
  cout << a << endl;
};
mat operator*(const mat &a, const mat &b) {
  mat c(a.size(), vec(b[0].size()));
  for (int i = 0; i < a.size(); i++) {
    for (int j = 0; j < a[0].size(); j++) {
      if (a[i][j]) {
        for (int k = 0; k < b[0].size(); k++) {
          add_mod(c[i][k], a[i][j] * b[j][k] % mod);
        }
      }
    }
  }
  return c;
}
vec operator*(const mat &a, const vec &b) {
  vec c(a.size());
  for (int i = 0; i < a.size(); i++) {
    for (int j = 0; j < a[0].size(); j++) {
      add_mod(c[i], a[i][j] * b[j] % mod);
    }
  }
  return c;
}
mat pow(mat a, ull n) {
  mat res(a.size(), vec(a[0].size()));
  for (int i = 0; i < a.size(); i++) {
    res[i][i] = 1;
  }
  while (n) {
    if (n & 1) {
      res = res * a;
    }
    a = a * a;
    n >>= 1;
  }
  return res;
}
std::ostream &operator<<(std::ostream &os, __int128 T) {
  if (T < 0) os << "-";
  if (T >= 10) os << T / 10;
  if (T <= -10) os << (-(T / 10));
  return os << ((int)(T % 10) > 0 ? (int)(T % 10) : -(int)(T % 10));
}
__int128 LPOW(__int128 x, ll n) {
  __int128 res = 1;
  for (; n; n /= 2, x *= x, x %= mod) {
    if (n & 1) {
      res *= x;
      res %= mod;
    }
  }
  return res;
}
ll POW(ll x, ll n) {
  ll res = 1;
  for (; n; n /= 2, x *= x, x %= mod) {
    if (n & 1) {
      res *= x;
      res %= mod;
    }
  }
  return res;
}
ll INV(ll x) { return POW(x, mod - 2); }
ll inv(ll x) { return x == 1 ? 1 : (mod - mod / x * inv(mod % x) % mod); }
void rotate(double &x, double &y, double theta) {
  double tx = cos(theta) * x - sin(theta) * y;
  double ty = sin(theta) * x + cos(theta) * y;
  x = tx, y = ty;
}
namespace bit {
const int BIT_N = 1e5 + 5;
int bit[BIT_N];
int sum(int x) {
  int res = 0;
  while (x) {
    res += bit[x];
    x -= x & -x;
  }
  return res;
}
int sum(int l, int r) {
  if (l > r) return 0;
  return sum(r) - sum(l - 1);
}
void add(int x, int v, int n) {
  while (x <= n) {
    bit[x] += v;
    x += x & -x;
  }
}
}  // namespace bit
namespace util {
int len(ll x) { return snprintf(nullptr, 0, "%lld", x); }
vi get_d(ll x) {
  vi res;
  while (x) {
    res.push_back(x % 10);
    x /= 10;
  }
  reverse(res.begin(), res.end());
  return res;
}
template <class T>
T parity(const T &a) {
  return a & 1;
}
template <class T>
void out(const vector<T> &a) {
  std::copy(a.begin(), a.end(), std::ostream_iterator<T>(std::cout, ", "));
  cout << endl;
};
}  // namespace util
using namespace util;
const ll LINF = LLONG_MAX / 10;
const int INF = INT_MAX / 10;
const int M = 3000 + 5;
const int N = 5e5 + 5;
struct edge {
  int v, i, next;
} E[2 * N];
int last[N];
int cnt;
void insert(int u, int v, int i) {
  E[++cnt] = {v, i, last[u]};
  last[u] = cnt;
  E[++cnt] = {u, i, last[v]};
  last[v] = cnt;
}
bool used[N];
int size[N];
int ma[N];
int root, sum;
void centroid(int u, int f) {
  size[u] = 1, ma[u] = 0;
  for (int i = last[u]; i; i = E[i].next) {
    int &v = E[i].v;
    if (v != f && !used[v]) {
      centroid(v, u);
      size[u] += size[v];
      ma[u] = max(ma[u], size[v]);
    }
  }
  ma[u] = max(ma[u], sum - size[u]);
  if (ma[root] > ma[u]) root = u;
};
int last_edge2[N][2][2];
inline int work(int u, int c) {
  if (c != last_edge2[u][0][0]) {
    if (c != last_edge2[u][1][0])
      return 0;
    else
      return last_edge2[u][0][1];
  } else
    return last_edge2[u][1][1];
};
int main() {
  cout << std::fixed;
  cout << setprecision(10);
  int T;
  scan(T);
  while (T--) {
    ll a, b, c, d;
    scan(a, b, c, d);
    if (a >= b && c >= b - 1 && d >= b) {
      println("Yes");
      continue;
    }
    set<ll> s;
    while (a >= b) {
      if (s.find(a) != s.end()) {
        println("Yes");
        break;
      }
      s.insert(a);
      ll t = (a - c + b - 1) / b * b;
      t = max(t, b);
      a -= t;
      if (a < 0) break;
      a += d;
    }
    if (a < b) println("No");
  }
  return 0;
}
