unittest
{

assert( q"INPUT
14
9 7 5 9
9 7 6 9
14 10 7 12
14 10 8 12
14 10 9 12
14 10 7 11
14 10 8 11
14 10 9 11
9 10 5 10
10 10 5 10
11 10 5 10
16 10 5 10
1000000000000000000 17 14 999999999999999985
1000000000000000000 17 15 999999999999999985
INPUT".split( '\n' ).parse.expand.solve.format!( "%s\n" ) == q"OUTPUT
No
Yes
No
Yes
Yes
No
No
Yes
No
Yes
Yes
No
No
Yes
OUTPUT" );

assert( q"INPUT
24
1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
2 1 4 3
2 3 1 4
2 3 4 1
2 4 1 3
2 4 3 1
3 1 2 4
3 1 4 2
3 2 1 4
3 2 4 1
3 4 1 2
3 4 2 1
4 1 2 3
4 1 3 2
4 2 1 3
4 2 3 1
4 3 1 2
4 3 2 1
INPUT".split( '\n' ).parse.expand.solve.format!( "%s\n" ) == q"OUTPUT
No
No
No
No
No
No
Yes
Yes
No
No
No
No
Yes
Yes
Yes
No
No
No
Yes
Yes
Yes
No
No
No
OUTPUT" );

}



import std.algorithm;
import std.conv;
import std.format;
import std.math;
import std.range;
import std.stdio;
import std.typecons;

void main()
{
	stdin.byLineCopy.parse.expand.solve.writeln;
}

auto parse( Range )( Range input )
if( isInputRange!Range && is( ElementType!Range == string ) )
{
	auto t = input.front.to!( long );
	auto abcds = new long[ 4 ][ t ];
	foreach( ref abcd; abcds )
	{
		input.popFront;
		abcd = input.front.split.to!( long[] );
	}
	return tuple( abcds );
}

auto solve( long[ 4 ][] abcds )
{
	auto anss = new bool[ abcds.length ];
	foreach( ref ans, abcd; lockstep( anss, abcds ) )
	{
		if( abcd[ 0 ] < abcd[ 1 ] )
		{
			// 在庫の初日本数(A)より購入本数(B)のほうが多いので絶対ダメ
			ans = false;
		}
		else if( abcd[ 3 ] < abcd[ 1 ] )
		{
			// 仕入れの本数(D)より購入本数(B)のほうが多いので絶対ダメ
			ans = false;
		}
		else if( abcd[ 1 ] <= abcd[ 2 ] )
		{
			// 購入本数(B)より在庫の最低本数(C)のほうが多いので絶対大丈夫
			ans = true;
		}
		else
		{
			// 購入本数(B)より仕入れの本数(D)のほうが多いが、在庫の最低本数(C)は購入本数(B)より少ない
			auto r = abcd[ 0 ] % abcd[ 1 ];
			auto d = abcd[ 3 ] % abcd[ 1 ];
			if( d == 0 )
			{
				// 仕入れの本数(D)と購入本数(B)が釣り合ってるので、最初の仕入れの前に在庫が無くならなければ大丈夫
				ans = ( r <= abcd[ 2 ] );
			}
			else
			{
				// 在庫の残り本数が 在庫の最低本数(C)超 かつ 購入本数(B)未満 になるタイミングがなければ大丈夫
				long[ long ] rs;
				do
				{
					rs[ r ] = true;
					r += ( cast( long )( ( abcd[ 2 ] - r + 1.0L ) / d ).ceil * d ) - abcd[ 1 ];
				}
				while( 0 <= r && r !in rs );
				ans = ( 0 <= r );
			}
		}
	}
	return anss.map!( ( a ) => a ? "Yes" : "No" ).join( "\n" );
}
