Takahashi and Aoki will have a battle using their monsters.
The health and strength of Takahashi's monster are A and B, respectively, and those of Aoki's monster are C and D, respectively.
The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ...
Here, an attack decreases the opponent's health by the value equal to the attacker's strength.
The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.
If Takahashi will win, print Yes; if he will lose, print No.

-----Constraints-----
 - 1 \leq A,B,C,D \leq 100
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
A B C D

-----Output-----
If Takahashi will win, print Yes; if he will lose, print No.

-----Sample Input-----
10 9 10 10

-----Sample Output-----
No

First, Takahashi's monster attacks Aoki's monster, whose health is now 10-9=1.
Next, Aoki's monster attacks Takahashi's monster, whose health is now 10-10=0.
Takahashi's monster is the first to have 0 or less health, so Takahashi loses.

Difficulty: EASY

Solutions:
(a, b, c, d) = map(int, input().split())
if -(-a // d) + 1 > -(-c // b):
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
x = -(-c // b)
y = -(-a // d)
if x <= y:
	print('Yes')
else:
	print('No')


class Monster:

	def __init__(self, hp, attack):
		self.hp = hp
		self.attack = attack
		self.death = False

class Game:

	def __init__(self, monsters: list):
		self.monsters = monsters

	def calc_damage(self, offence, defence):
		self.monsters[defence].hp -= self.monsters[offence].attack
		if self.monsters[defence].hp <= 0:
			self.monsters[defence].death = True
		return self.monsters[defence].death

	def battle(self):
		while True:
			self.calc_damage(0, 1)
			if self.monsters[1].death:
				print('Yes')
				break
			self.calc_damage(1, 0)
			if self.monsters[0].death:
				print('No')
				break
(a, b, c, d) = list(map(int, input().split()))
t_monster = Monster(a, b)
a_monster = Monster(c, d)
game = Game([t_monster, a_monster])
game.battle()


(A, B, C, D) = map(int, input().split())
import math
if math.ceil(A / D) >= math.ceil(C / B):
	print('Yes')
else:
	print('No')


import math
(a, b, c, d) = map(int, input().split())
print('Yes' if math.ceil(a / d) > math.ceil(c / b) - 1 else 'No')


(A, B, C, D) = map(int, input().split())
while True:
	C -= B
	if C <= 0:
		print('Yes')
		return
	A -= D
	if A <= 0:
		print('No')
		return


(A, B, C, D) = map(int, input().split())
print('Yes' if (A + D - 1) // D >= (C + B - 1) // B else 'No')


(a, b, c, d) = map(int, input().split())
print('YNeos'[0 - -a // d < 0 - -c // b::2])


(A, B, C, D) = map(int, input().split())
while A > 0 and C > 0:
	A = A - D
	C = C - B
if C <= 0:
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
T = -(-c // b)
A = -(-a // d)
print(['Yes', 'No'][A < T])


(a, b, c, d) = map(int, input().split())
while a > 0 and c > 0:
	c -= b
	a -= d
print('Yes' if c <= 0 else 'No')


class Monster:

	def __init__(self, hp, at):
		self.hp = hp
		self.at = at

	def fight(self, at) -> int:
		self.hp -= at
		return self.hp

	def is_loser(self) -> bool:
		return self.hp <= 0
(A, B, C, D) = map(int, input().split())
takahashi_monster = Monster(A, B)
aoki_monster = Monster(C, D)
while True:
	aoki_monster.fight(B)
	if aoki_monster.is_loser():
		result = 'Yes'
		break
	takahashi_monster.fight(D)
	if takahashi_monster.is_loser():
		result = 'No'
		break
print(result)


(a, b, c, d) = map(int, input().split())
tak = -(-a // d)
aoki = -(-c // b)
if tak < aoki:
	print('No')
else:
	print('Yes')


(A, B, C, D) = list(map(int, input().split()))

def answer(A: int, B: int, C: int, D: int) -> str:
	while True:
		C -= B
		if C <= 0:
			return 'Yes'
			break
		A -= D
		if A <= 0:
			return 'No'
			break
print(answer(A, B, C, D))


(a, b, c, d) = map(int, input().split())
flg = 0
for i in range(10 ** 100):
	if flg == 0:
		c -= b
		flg = 1
	else:
		a -= d
		flg = 0
	if a <= 0 or c <= 0:
		print('Yes' if c <= 0 else 'No')
		break


(a, b, c, d) = map(int, input().split())
s = -(-a // d)
t = -(-c // b)
if s >= t:
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
t = (a - 1) // d + 1
ao = (c - 1) // b + 1
if t - ao >= 0:
	print('Yes')
else:
	print('No')


(A, B, C, D) = map(int, input().split())
X = -(-A // D)
Y = -(-C // B)
if X >= Y:
	print('Yes')
else:
	print('No')


import sys

def __starting_point():
	(A, B, C, D) = list(map(int, input().split()))
	while True:
		C -= B
		if C <= 0:
			print('Yes')
			return
		A -= D
		if A <= 0:
			print('No')
			return
__starting_point()


(a, b, c, d) = list(map(int, input().split()))
ad = -(-a // d)
cb = -(-c // b)
print('Yes' if ad >= cb else 'No')


(A, B, C, D) = map(int, input().split())
a = -(-C // B)
b = -(-A // D)
if a <= b:
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
e = -(-c // b)
f = -(-a // d)
if e <= f:
	print('Yes')
else:
	print('No')


import math
(a, b, c, d) = map(int, input().split())
(x, y) = (math.ceil(a / d), math.ceil(c / b))
print('Yes' if x >= y else 'No')


(A, B, C, D) = list(map(int, input().split()))
turn = 0
while A > 0 and C > 0:
	if turn == 0:
		C -= B
		turn = 1
	else:
		A -= D
		turn = 0
if A <= 0:
	print('No')
else:
	print('Yes')


import math
(A, B, C, D) = list(map(int, input().split()))
while True:
	C -= B
	if C <= 0:
		print('Yes')
		break
	A -= D
	if A <= 0:
		print('No')
		break


a = list(map(int, input().split()))
if -(-a[0] // a[3]) >= -(-a[2] // a[1]):
	print('Yes')
else:
	print('No')


(a, b, c, d) = list(map(int, input().split()))
while True:
	c -= b
	if c <= 0:
		print('Yes')
		break
	a -= d
	if a <= 0:
		print('No')
		break


(a, b, c, d) = map(int, input().split())
ac = c / b
cc = -(-a // d)
if ac <= cc:
	print('Yes')
else:
	print('No')


(A, B, C, D) = map(int, input().split())
m = A // D
n = C // B
if A % D != 0:
	m += 1
if C % B != 0:
	n += 1
if m >= n:
	print('Yes')
else:
	print('No')


(tH, tA, aH, aA) = map(int, input().split())
print('Yes') if (aH - 1) // tA + 1 <= (tH - 1) // aA + 1 else print('No')


(a, b, c, d) = map(int, input().split())
takahashi_hp = a
aoki_hp = c
while True:
	aoki_hp = aoki_hp - b
	if aoki_hp <= 0:
		print('Yes')
		break
	takahashi_hp = takahashi_hp - d
	if takahashi_hp <= 0:
		print('No')
		break


(A, B, C, D) = list(map(int, input().split()))
result = 'Yes'
while A > 0 or C > 0:
	C -= B
	A -= D
	if C <= 0:
		break
	elif A <= 0:
		result = 'No'
		break
print(result)


import math
(a, b, c, d) = map(int, input().split())
x = math.ceil(a / d)
z = math.ceil(c / b)

def result():
	if x >= z:
		return 'Yes'
	else:
		return 'No'
print(result())


(a, b, c, d) = map(int, input().split())
while 1:
	c -= b
	if c <= 0:
		print('Yes')
		break
	a -= d
	if a <= 0:
		print('No')
		break


import math
(a, b, c, d) = map(int, input().split())
N = math.ceil(c / b)
print(['No', 'Yes'][a - (N - 1) * d > 0])


(a, b, c, d) = [int(j) for j in input().split()]
p = -(-c // b)
q = -(-a // d)
if p <= q:
	print('Yes')
else:
	print('No')


(A, B, C, D) = list(map(int, input().split()))
T = -(-C // B)
AO = -(-A // D)
print('Yes' if T <= AO else 'No')


import sys
(a, b, c, d) = map(int, input().split())
for _ in range(100):
	a_t = c - b
	if a_t <= 0:
		print('Yes')
		return
	c = a_t
	t_t = a - d
	if t_t <= 0:
		print('No')
		return
	a = t_t


(a, b, c, d) = map(int, input().split())
(p, q) = (c // b + (c % b > 0), a // d + (a % d > 0))
print('Yes') if p <= q else print('No')


(A, B, C, D) = map(int, input().split())
taka = 0
aoki = 0
while A > 0:
	A -= D
	taka += 1
while C > 0:
	C -= B
	aoki += 1
if taka >= aoki:
	print('Yes')
else:
	print('No')


def battle():
	(A, B, C, D) = map(int, input().split())
	attackT = A // D
	attackA = C // B
	if A % D != 0:
		attackT += 1
	if C % B != 0:
		attackA += 1
	res = 'Yes'
	if attackT < attackA:
		res = 'No'
	print(res)
battle()


(a, b, c, d) = map(int, input().split())
ta = 0 - -c // b
ao = 0 - -a // d
if ta <= ao:
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
print('Yes' if int(c / b + 0.9999) <= int(a / d + 0.9999) else 'No')


(a, b, c, d) = map(int, input().split())
taka = -(-c // b)
ao = -(-a // d)
if taka <= ao:
	print('Yes')
	exit()
print('No')


(A, B, C, D) = map(int, input().split())
x = -(-A // D)
y = -(-C // B)
if x >= y:
	print('Yes')
else:
	print('No')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, bisect
import sys
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
stdin = sys.stdin
ni = lambda : int(ns())
nf = lambda : float(ns())
na = lambda : list(map(int, stdin.readline().split()))
nb = lambda : list(map(float, stdin.readline().split()))
ns = lambda : stdin.readline().rstrip()
(A, B, C, D) = na()
t = (C + B - 1) // B
a = (A + D - 1) // D
print('Yes') if t <= a else print('No')


from math import ceil
(a, b, c, d) = map(int, input().split())
A = ceil(c / b)
B = ceil(a / d)
print('Yes' if A <= B else 'No')


monsters = input()
list = monsters.split(' ')
a = int(list[0])
b = int(list[1])
c = int(list[2])
d = int(list[3])
while True:
	c = c - b
	if c <= 0:
		print('Yes')
		break
	a = a - d
	if a <= 0:
		print('No')
		break


(a, b, c, d) = map(int, input().split())
print('YNeos'[(c - 1) // b > (a - 1) // d::2])


def main() -> None:
	(a, b, c, d) = list(map(int, input().split()))
	if a % d == 0:
		turn_t = a // d
	else:
		turn_t = a // d + 1
	if c % b == 0:
		turn_a = c // b
	else:
		turn_a = c // b + 1
	print('Yes' if turn_a <= turn_t else 'No')
	return

def __starting_point():
	main()
__starting_point()


(a, b, c, d) = [int(x) for x in input().split()]
if (c - 1) // b > (a - 1) // d:
	print('No')
else:
	print('Yes')


(a, b, c, d) = map(int, input().split())
T = c // b + (c % b != 0)
A = a // d + (a % d != 0)
print('Yes' if T <= A else 'No')


(a, b, c, d) = [int(i) for i in input().split()]
c = -(-c // b)
a = -(-a // d)
print('Yes' if c <= a else 'No')


(tkhp, tkat, aohp, aoat) = list(map(int, input().split()))
while True:
	aohp -= tkat
	if aohp <= 0:
		print('Yes')
		break
	tkhp -= aoat
	if tkhp <= 0:
		print('No')
		break


(th, ta, ah, aa) = map(int, input().split())
if -(-ah // ta) <= -(-th // aa):
	print('Yes')
else:
	print('No')


import math
(a, b, c, d) = map(float, input().split())
if c <= b * math.ceil(a / d):
	print('Yes')
else:
	print('No')


(A, B, C, D) = map(int, input().split())
Ta = -(-C // B)
Ao = -(-A // D)
print('Yes' if Ta <= Ao else 'No')


(A, B, C, D) = map(int, input().split())
d = C // B
e = C % B
if e == 0:
	d = d - 1
if d * D >= A:
	print('No')
else:
	print('Yes')


(a, b, c, d) = list(map(int, input().split()))
for i in range(220):
	if i % 2 == 0:
		c -= b
	else:
		a -= d
	if c <= 0:
		print('Yes')
		return
	elif a <= 0:
		print('No')
		return


class Monster:

	def __init__(self, hp, power):
		self.hp = hp
		self.power = power

	def fight(self, power) -> int:
		self.hp -= power
		return self.hp

	def is_loser(self) -> bool:
		return self.hp <= 0
(a, b, c, d) = list(map(int, input().split()))
takahashi_monster = Monster(a, b)
aoki_monster = Monster(c, d)
result = 'ret'
while True:
	aoki_monster.fight(b)
	if aoki_monster.is_loser():
		result = 'Yes'
		break
	takahashi_monster.fight(d)
	if takahashi_monster.is_loser():
		result = 'No'
		break
print(result)


(a, b, c, d) = list(map(int, input().split()))

def answer(a: int, b: int, c: int, d: int) -> str:
	if (c + b - 1) // b <= (a + d - 1) // d:
		return 'Yes'
	else:
		return 'No'
print(answer(a, b, c, d))


(a, b, c, d) = map(int, input().split())
if c % b == 0:
	t = c / b
else:
	t = c // b + 1
if a % d == 0:
	o = a / d
else:
	o = a // d + 1
if t > o:
	print('No')
elif t <= o:
	print('Yes')


def i_input():
	return int(input())

def i_map():
	return map(int, input().split())

def i_list():
	return list(map(int, input().split()))

def i_row(N):
	return [int(input()) for _ in range(N)]

def i_row_list(N):
	return [list(map(int, input().split())) for _ in range(N)]
(tHP, tATK, aHP, aATK) = i_map()
while True:
	aHP = max(aHP - tATK, 0)
	if aHP == 0:
		ans = 'Yes'
		break
	tHP = max(tHP - aATK, 0)
	if tHP == 0:
		ans = 'No'
		break
print(ans)


(A, B, C, D) = map(int, input().split())
while A > 0:
	C -= B
	if C <= 0:
		print('Yes')
		exit()
	A -= D
print('No')


(a1, a2, b1, b2) = map(int, input().split())
if -(-b1 // a2) <= -(-a1 // b2):
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
print(['No', 'Yes'][a // d + (a % d > 0) >= c // b + (c % b > 0)])


(A, B, C, D) = map(int, input().split())
while C > 0 or A > 0:
	C -= B
	if C <= 0:
		print('Yes')
		break
	A -= D
	if A <= 0:
		print('No')
		break


(A, B, C, D) = map(int, input().split())
print('YNeos'[(A + D - 1) // D < (C + B - 1) // B::2])


(a, b, c, d) = map(int, input().split())
N = -(-c // b)
M = -(-a // d)
if N <= M:
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
takahashi_turn = 0
aoki_turn = 0
while c - b > 0:
	takahashi_turn += 1
	c -= b
while a - d > 0:
	aoki_turn += 1
	a -= d
if takahashi_turn <= aoki_turn:
	print('Yes')
else:
	print('No')


(A, B, C, D) = [int(x) for x in input().split()]
t = (C + B - 1) // B
a = (A + D - 1) // D
print('Yes' if t <= a else 'No')


(hp1, atk1, hp2, atk2) = map(int, input().split())
print('Yes' if hp2 / atk1 <= -(-hp1 // atk2) else 'No')


(t_hp, t_atk, a_hp, a_atk) = list(map(int, input().split()))
t_count = 0
a_count = 0
while a_hp > 0:
	a_hp -= t_atk
	t_count += 1
while t_hp > 0:
	t_hp -= a_atk
	a_count += 1
if t_count <= a_count:
	print('Yes')
else:
	print('No')


(a, b, c, d) = map(int, input().split())
cna = (a + d - 1) // d
cnc = (c + b - 1) // b
print(['Yes', 'No'][cna < cnc])


(a, b, c, d) = map(int, input().split())
j = -(-c // b)
k = -(-a // d)
if j <= k:
	print('Yes')
else:
	print('No')


(A, B, C, D) = map(int, input().split())
-(-4 // 3)
if -(-C // B) > -(-A // D):
	print('No')
else:
	print('Yes')