In some game by Playrix it takes t minutes for an oven to bake k carrot cakes, all cakes are ready at the same moment t minutes after they started baking. Arkady needs at least n cakes to complete a task, but he currently don't have any. However, he has infinitely many ingredients and one oven. Moreover, Arkady can build one more similar oven to make the process faster, it would take d minutes to build the oven. While the new oven is being built, only old one can bake cakes, after the new oven is built, both ovens bake simultaneously. Arkady can't build more than one oven.

Determine if it is reasonable to build the second oven, i.e. will it decrease the minimum time needed to get n cakes or not. If the time needed with the second oven is the same as with one oven, then it is unreasonable.


-----Input-----

The only line contains four integers n, t, k, d (1 ≤ n, t, k, d ≤ 1 000) — the number of cakes needed, the time needed for one oven to bake k cakes, the number of cakes baked at the same time, the time needed to build the second oven. 


-----Output-----

If it is reasonable to build the second oven, print "YES". Otherwise print "NO".


-----Examples-----
Input
8 6 4 5

Output
YES

Input
8 6 4 6

Output
NO

Input
10 3 11 4

Output
NO

Input
4 2 1 4

Output
YES



-----Note-----

In the first example it is possible to get 8 cakes in 12 minutes using one oven. The second oven can be built in 5 minutes, so after 6 minutes the first oven bakes 4 cakes, the second oven bakes 4 more ovens after 11 minutes. Thus, it is reasonable to build the second oven. 

In the second example it doesn't matter whether we build the second oven or not, thus it takes 12 minutes to bake 8 cakes in both cases. Thus, it is unreasonable to build the second oven.

In the third example the first oven bakes 11 cakes in 3 minutes, that is more than needed 10. It is unreasonable to build the second oven, because its building takes more time that baking the needed number of cakes using the only oven.

Difficulty: EASY
Tags: Implementation

Complete search
Skill types: Complete search

Starter code:

Solutions:
def mp():
	return map(int, input().split())

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

def pt(x):
	print(x)

def ip():
	return input()

def it():
	return int(input())

def sl(x):
	return [t for t in x]

def spl(x):
	return x.split()

def aj(liste, item):
	liste.append(item)

def bin(x):
	return '{0:b}'.format(x)

def listring(l):
	return ' '.join([str(x) for x in l])

def ptlist(l):
	print(' '.join([str(x) for x in l]))
(n, t, k, d) = mp()

def time(x):
	return x // t * k
x = 0
while time(x) < n:
	x += 1
z = 0
while time(z) + time(z + d) < n:
	z += 1
if x > z + d:
	pt('YES')
else:
	pt('NO')


import sys
from math import ceil

def main(args=None):
	if args is None:
		(n, t, k, d) = [int(tok.strip()) for tok in sys.stdin.readline().split()]
	else:
		(n, t, k, d) = args
	t1 = ceil(n / k) * t
	t_min = t1
	for tx in range(d + 1, t1):
		n2 = tx // t * k + (tx - d) // t * k
		if n2 >= n:
			t_min = tx
			break
	if t_min < t1:
		return 'YES'
	else:
		return 'NO'
print(main())


import math
lt = list(input().split())
(n, t, k, d) = (int(lt[0]), int(lt[1]), int(lt[2]), int(lt[3]))
if d < math.ceil(n / k) * t - t:
	print('YES')
else:
	print('NO')


(noOfCakesToBeMade, minsOvenReqToBakeABatchOfCakes, noOfCakesInABatch, minsReqToBuildAOven) = [int(x) for x in input().split(' ')]
noOfCakesReady = 0
timer = 0
while timer <= minsReqToBuildAOven:
	noOfCakesReady += noOfCakesInABatch
	timer += minsOvenReqToBakeABatchOfCakes
if noOfCakesReady < noOfCakesToBeMade:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
a = (n + k - 1) // k * t
b = 0
c = d
while n > 0:
	n -= k
	b += t
	if n <= 0:
		break
	if b > d:
		n -= k
		c += t
		if n <= 0:
			break
if b < a or (c < a and c != d):
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
T1 = (n + k - 1) // k * t
numb = (d + t - 1) // t * k
time = (d + t - 1) // t * t
if numb >= n:
	print('NO')
	exit()
T2 = (n - numb + 2 * k - 1) // (2 * k) * t + d - time + d
print('YES' if T1 > T2 else 'NO')


import math
(n, t, k, d) = list(map(int, input().split()))
total_time = math.ceil(n / k) * t
if total_time - t > d:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
print('YES' if (d // t + 1) * k < n else 'NO')


import sys
import math

def readlines(type=int):
	return list(map(type, sys.stdin.readline().split()))

def read(type=int):
	return type(sys.stdin.readline().strip())
joint = lambda it, sep=' ': sep.join([str(i) if type(i) != list else sep.join(map(str, i)) for i in it])

def solve_naive(n, t, k, d):
	n_mul = n * t // k + 1
	t_muls = set()
	for i in range(1, n_mul + 1):
		t_muls.add(t * i)
		t_muls.add(t * i + d)
	t_muls = sorted(list(t_muls))
	for mul in t_muls:
		yeild = k * (mul // t + (mul - d) // t)
		if yeild >= n:
			break
	if mul < t * math.ceil(n / k):
		return 'YES'
	return 'NO'

def solve(n, t, k, d):
	timet = (n * t + k * d) / (2 * k)
	c1 = math.ceil(timet / t) * t
	c2 = math.ceil((timet - d) / t) * t + d
	if c1 < t * math.ceil(n / k) and k * (c1 // t + (c1 - d) // t) >= n:
		return 'YES'
	if c2 < t * math.ceil(n / k) and k * (c2 // t + (c2 - d) // t) >= n:
		return 'YES'
	return 'NO'

def main():
	args = readlines()
	print(solve(*args))
main()


(n, t, k, d) = map(int, input().split())
s = 0
second = False
finish = -1
for i in range(1, (n // k + 1) * t + 1):
	if second and (i - start) % t == 0:
		s += k
	if i == d:
		second = True
		start = i
	if i % t == 0:
		s += k
	if s >= n:
		finish = i
		break
if n % k == 0:
	if n // k * t > finish:
		print('YES')
	else:
		print('NO')
elif (n // k + 1) * t > finish:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split())
if k > n:
	print('NO')
else:
	t1 = t * math.ceil(n / k)
	rem = n - d / t * k
	t2 = d + math.ceil(rem / 2 / k) * t
	if t1 > t2:
		print('YES')
	else:
		print('NO')


(n, t, k, d) = map(int, input().split())
(q, w) = ((n + k - 1) // k, (d + t - 1) // t)
print('YES' if q * t > w * t + (q - w + 1) // 2 * t - (w * t - d) * (q - w == 1) else 'NO')


(n, t, k, d) = [int(u) for u in input().split()]
if n < k:
	print('NO')
else:
	if n % k == 0:
		a = n / k * t
	else:
		a = (n // k + 1) * t
	r = d // t
	if n - k * r > k:
		print('YES')
	else:
		print('NO')


import math
nums = list(map(int, input().split()))
tot_cakes = nums[0]
time_k_cakes = nums[1]
k_cakes = nums[2]
time_oven = nums[3]
num_bakes = math.ceil(tot_cakes / k_cakes)
T1 = num_bakes * time_k_cakes
oven1 = 0
oven2 = time_oven
for _ in range(0, num_bakes):
	if oven1 <= oven2:
		oven1 += time_k_cakes
	else:
		oven2 += time_k_cakes
T2 = max(oven1, oven2)
if T1 > T2:
	print('YES')
else:
	print('NO')


import math
build_oven = 'NO'
(n, t, k, d) = map(int, input().split())
baking_time = math.ceil(n / k) * t
o1 = t
o2 = t + d
for i in range(baking_time):
	if o1 == 0:
		n -= k
		o1 = t
	if o2 == 0:
		n -= k
		o2 = t
	if n < 1:
		build_oven = 'YES'
	o1 -= 1
	o2 -= 1
print(build_oven)


ns = [int(s) for s in input().split(' ')]
n = ns[0]
t = ns[1]
k = ns[2]
d = ns[3]
db = 0
together = d % t
runs_o = d // t
cakes_during_building = d // t * k
after_building = n - cakes_during_building
if db == 1:
	print('left cakes to make after d: ', after_building)
	print('cakes made druing d: ', cakes_during_building)
	print('total cakes: ', n)
	print('d :', d)
	print('cakes per min :', k, t)
	print(together)
	print(runs_o)
if after_building <= 0 or after_building <= k:
	print('NO')
else:
	print('YES')


(a, b, c, d) = map(int, input().split())
if (d // b + 1) * c < a:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))
n = a[0]
t = a[1]
k = a[2]
d = a[3]
c = 0
while c <= d:
	n -= k
	c += t
if n > 0:
	print('YES')
else:
	print('NO')


import collections as col
import itertools as its
import sys
import operator
from bisect import bisect_left, bisect_right
from copy import copy, deepcopy
from math import factorial as fact

class Solver:

	def __init__(self):
		pass

	def solve(self):
		(n, t, k, d) = map(int, input().split())
		n = (n + k - 1) // k
		if d < (n - 1) * t:
			print('YES')
		else:
			print('NO')
s = Solver()
s.solve()


(n, t, k, d) = map(int, input().split())
print(('YES', 'NO')[d % t == 0 and (d + t) // t * k >= n or (d + t - 1) // t * k >= n])


(n, t, k, d) = map(int, input().split())
a1 = -(-n // k) * t
a2 = 0
p = 0
(c1, c2) = (t, t)
while p < n:
	if a2 >= d:
		c2 -= 1
	c1 -= 1
	if c1 == 0:
		c1 = t
		p += k
	if c2 == 0:
		c2 = t
		p += k
	a2 += 1
if a2 < a1:
	print('YES')
else:
	print('NO')


data = input('').split(' ')
(n, t, k, d) = [int(i) for i in data]
sum = 1 if n % k != 0 else 0
time_one_oven = (n // k + sum) * t
time_build_oven = d + t
if time_build_oven < time_one_oven:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
div = d // t
if div == 0:
	if n - k > 0:
		print('YES')
	else:
		print('NO')
elif n - (div + 1) * k > 0:
	print('YES')
else:
	print('NO')


(n, t, m, d) = map(int, input().split())
x = t * n / m
t1 = d + t
y = t1 // t * m
if y >= n:
	print('NO')
else:
	print('YES')


from math import ceil

def cakes(n, t, k, d):
	if ceil(n / k) * t - d > t:
		return 'YES'
	return 'NO'
(N, T, K, D) = [int(i) for i in input().split()]
print(cakes(N, T, K, D))


from sys import stdin, stdout

def readint():
	return map(int, stdin.readline().split())
(n, t, k, d) = readint()
tt = n // k * t
if n % k:
	tt += t
if tt > d + t:
	print('YES')
else:
	print('NO')


(a1, a2, a3, a4) = list(map(int, input().split()))

def pies_for_time(time: int, t, k):
	if time <= 0:
		return 0
	return time // t * k

def pies(n, t, k, d):
	t1 = (n // k + (0 if n % k == 0 else 1)) * t
	pp1 = pies_for_time(t1 - 1, t, k)
	pp2 = pies_for_time(t1 - d - 1, t, k)
	if pp1 + pp2 >= n:
		return 'YES'
	return 'NO'
print(pies(a1, a2, a3, a4))


import sys

def solve():
	(n, t, k, d) = map(int, input().split())
	use = (n + k - 1) // k
	if d < (use - 1) * t:
		ans = 'YES'
	else:
		ans = 'NO'
	print(ans)
solve()


(n, t, k, d) = map(int, input().split())
t1 = t * ((n + k - 1) // k)
n2 = 0
t2 = 0
while n2 < n:
	t2 += 1
	if t2 % t == 0:
		n2 += k
	if (t2 - d) % t == 0 and t2 - d > 0:
		n2 += k
if t2 < t1:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = list(map(int, input().split()))
t1 = math.ceil(n / k) * t
a = d // t
b = n - a * k
b /= 2
t2 = d + math.ceil(b / k) * t
print('YES' if t2 < t1 else 'NO')


import math
(n, t, k, d) = [int(i) for i in input().split()]
total = math.ceil(n / k * t)
time = 0
ovenBuilt = 0
while n > 0:
	time += 1
	if time % t == 0:
		n -= k
		if ovenBuilt:
			n -= k
	if not ovenBuilt and time == d:
		ovenBuilt = 1
print('YES', end='') if time < total else print('NO', end='')


from sys import stdin
(n, t, k, d) = [int(x) for x in stdin.readline().strip().split()]

def solution(n, t, k, d):
	currt = 0
	while currt <= d:
		n -= k
		currt += t
	if n > 0:
		return 'YES'
	else:
		return 'NO'
print(solution(n, t, k, d))


from math import *
(n, t, k, d) = map(float, input().split(' '))
c = ceil(n / k)
if d < (c - 1) * t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
a = (n + k - 1) // k
o1 = 0
o2 = d
for i in range(a):
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
if max(o1, o2) < a * t:
	print('yes')
else:
	print('no')


import math
(n, t, k, d) = map(float, input().split())
one_oven = math.ceil(n / k) * t
times = int(d / t)
two_oven = times * t + math.ceil((n - times * k) / (2 * k)) * t
print('YES' if two_oven < one_oven else 'NO')


import math

def checa(n, t, k, d):
	t1 = math.ceil(n / k) * t
	r = math.floor(d / t) * k
	faltan = n - r
	if faltan <= 0:
		return 'NO'
	z = math.ceil(faltan / (2 * k)) * t
	t2 = z + d
	if t2 < t1:
		return 'YES'
	else:
		return 'NO'
(n, t, k, d) = list(map(int, input().split()))
print(checa(n, t, k, d))


import math
(n, t, k, d) = map(int, input().split())
if d // t * k + k < n:
	print('YES')
else:
	print('NO')


import math
str_input = input()
(n, t, k, d) = str_input.split()
n = int(n)
t = int(t)
k = int(k)
d = int(d)
if (math.ceil(n / k) * t - d) / t > 1:
	print('YES')
else:
	print('NO')


import math
(n, time, cakes, build_time) = map(int, input().split())
itr = math.ceil(n / cakes)
o1 = 0
o2 = build_time
for i in range(itr):
	if o1 < o2:
		o1 += time
	else:
		o2 += time
print('YES' if max(o1, o2) < itr * time else 'NO')


import sys
import math
(n, t, k, d) = input().split()
m = float(int(n) / int(k))
q = math.ceil(float(m))
if int(n) > int(k) and q * int(t) > int(t) + int(d):
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(i) for i in input().split()]
ost = d // t
ost *= k
if ost >= n:
	print('NO')
elif ost + k >= n:
	print('NO')
else:
	print('YES')


(n, t, k, d) = input().split(' ')
(n, t, k, d) = (int(n), int(t), int(k), int(d))
timeWithOneOven = n // k * t + (t if n % k != 0 else 0)
print('YES' if timeWithOneOven > d and timeWithOneOven - d > t else 'NO')


import math

def main():
	(n, t, k, d) = list(map(int, input().split()))
	if d + t < math.ceil(n / k) * t:
		print('YES')
	else:
		print('NO')

def __starting_point():
	main()
__starting_point()


(n, m, k, o) = [int(x) for x in input().split()]
t = n // k * m
if n <= k:
	print('No')
else:
	t1 = 0
	n1 = 0
	while t1 <= o:
		t1 += m
		n1 += k
	if n1 >= n:
		print('No')
	else:
		print('Yes')


(n, t, c, d) = map(int, input().split())
n2 = n
total1 = 0
total2 = 0
while n > 0:
	total1 += t
	n -= c
built = False
timer = 0
o1timer = 0
o2timer = 0
while n2 > 0:
	timer += 1
	o1timer += 1
	o2timer += 1
	if o1timer == t:
		n2 -= c
		o1timer = 0
	if not built and timer >= d:
		built = True
		o2timer = 0
		continue
	if built and o2timer == t:
		n2 -= c
		o2timer = 0
total2 = timer
if total2 < total1:
	print('YES')
else:
	print('NO')


(a, b, c, d) = map(int, input().split())
time = 0
cakes = 0
while cakes < a:
	cakes += c
	time += b
oven1 = time
time = 0
cakes = 0
while True:
	if cakes >= a:
		break
	time += 1
	if time > d and time % b == 0:
		cakes += c
	if cakes >= a:
		break
	if time % b == 0:
		cakes += c
oven2 = time
if oven2 < oven1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
fi = (n + k - 1) // k * t
t1 = 0
t2 = d
while n > 0:
	n -= k
	t1 += t
	if n <= 0:
		break
	if t1 > d:
		n -= k
		t2 += t
		if n <= 0:
			break
if t1 < fi or (t2 < fi and t2 != d):
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
t1 = 0
t2 = d
one = 0
b = 0
second = False
while b < n:
	one += t
	b += k
baked = 0
while baked < n:
	if t1 >= d:
		second = True
		t2 += t
		baked += k
	t1 += t
	baked += k
both = min(t1, t2)
if one <= both:
	print('NO')
elif not second:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
ans = 0
i = 0
while ans < n:
	i += 1
	if i % t == 0:
		ans += k
	if i - d > 0 and (i - d) % t == 0 and (ans < n):
		print('YES')
		break
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
t1 = 0
while t1 <= d:
	n -= k
	t1 += t
if n > 0:
	print('YES')
else:
	print('NO')


import math
(n, t, c, d) = input().split()
cakes_needed = int(n)
time = int(t)
cakes_in_progress = int(c)
second_oven = int(d)
patches = math.ceil(cakes_needed / cakes_in_progress)
oven1 = 0
oven2 = second_oven
for l in range(0, patches):
	if oven1 <= oven2:
		oven1 += time
	else:
		oven2 += time
if max(oven1, oven2) < patches * time:
	print('YES')
else:
	print('NO')


n = list(map(int, input().split()))
ot = n[0] / n[2] * n[1]
o1 = n[1]
o2 = n[3]
p = n[0] - n[2]
for i in range(n[0]):
	if p >= n[2]:
		if o2 > o1:
			o1 += n[1]
			p -= n[2]
		else:
			o1 += n[1]
			o2 += n[1]
			p -= n[2] + n[2]
	elif (p < n[2]) & (p > 0):
		t = p * n[1] / n[2]
		o1 += t
		o2 += t
		p = 0
if (o2 < ot) & (o2 != n[3]):
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = input().split()
(n, t, k, d) = (int(n), int(t), int(k), int(d))
(t1, t2) = (0, d)
use = math.ceil(n / k)
for i in range(use):
	if t1 <= t2:
		t1 += t
	else:
		t2 += t
if int(max(t1, t2)) >= use * t:
	print('NO')
else:
	print('YES')


import math

def solve():
	(n, t, k, d) = map(int, input().strip().split())
	x = math.ceil(d / t)
	y = int(x * t)
	mk = 0
	if d == y:
		mk = 1
	group_ks = math.ceil(n / k)
	if group_ks - x > mk:
		print('YES')
	else:
		print('NO')
solve()


def flor(i):
	if i == int(i):
		return i
	else:
		return int(i)

def cel(i):
	if i == int(i):
		return i
	else:
		return int(i) + 1
(n, t, k, d) = map(int, input().split())
if t * cel(n / k) > d + t * cel((cel(n / k) - flor(d / t)) / 2):
	print('YES')
else:
	print('NO')


inp = input()
inp = inp.split()
n = int(inp[0])
t = int(inp[1])
k = int(inp[2])
d = int(inp[3])
u = int((n + k - 1) / k)
t1 = 0
t2 = d
for i in range(u):
	if t1 < t2:
		t1 += t
	else:
		t2 += t
if max(t1, t2) < u * t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
cart = 0
while cart <= d:
	n -= k
	cart += t
if n > 0:
	print('YES')
else:
	print('No')


(n, t, k, d) = map(int, input('').split()[:4])
g = int((n + k - 1) / k)
o1 = 0
o2 = d
for i in range(g):
	if o1 < o2:
		o1 += t
	else:
		o2 += t
if max(o1, o2) < g * t:
	print('YES')
else:
	print('NO')


def main():
	(n, t, k, d) = map(int, input().split())
	time = 0
	single = 0
	double = 0
	while True:
		is_ready1 = time % t == 0 and time != 0
		is_ready2 = (time - d) % t == 0 and time > d
		if is_ready1:
			single += k
			double += k
		if is_ready2:
			double += k
		if single >= n:
			print('NO')
			return
		if double >= n:
			print('YES')
			return
		time += 1
main()


(n, t, k, d) = input().split()

def isReasonable(n, t, k, d):
	count = 1
	m = k
	while k < n:
		k += m
		count += 1
	nkt = count * t
	td = t + d
	if td < nkt:
		return 'YES'
	return 'NO'
print(isReasonable(int(n), int(t), int(k), int(d)))


(reqd, min_to_bake, bake_per_min, oven) = map(int, input().split())
h = 'NO'
x = reqd // bake_per_min
if reqd % bake_per_min == 0 and x * min_to_bake > min_to_bake + oven:
	h = 'YES'
if reqd % bake_per_min != 0 and (x + 1) * min_to_bake > min_to_bake + oven:
	h = 'YES'
print(h)


def main():
	(n, t, k, d) = map(int, input().split())
	b = (n + k - 1) // k
	if d < (b - 1) * t:
		print('YES')
	else:
		print('NO')
main()


import math
(num_cakes, oven_baking_time, num_simul_cakes, oven_build_time) = list(map(int, input().split()))
num_groups = math.ceil(num_cakes / num_simul_cakes)
(oven_1_available_time, oven_2_available_time) = (0, oven_build_time)
for i in range(num_groups):
	if oven_1_available_time <= oven_2_available_time:
		oven_1_available_time += oven_baking_time
	else:
		oven_2_available_time += oven_baking_time
two_furnaces_time = max(oven_1_available_time, oven_2_available_time)
one_furnace_time = num_groups * oven_baking_time
print('YES' if two_furnaces_time < one_furnace_time else 'NO')


(n, t, k, d) = map(int, input().split())
x = 0
if n % k == 0:
	x = n // k
else:
	x = n // k + 1
if x == 1:
	print('NO')
elif d // t == 0:
	print('YES')
else:
	m = d // t + 1
	if m < x:
		print('YES')
	else:
		print('NO')


import math
(n, t, k, d) = map(int, input().split())
one_oven = t * math.ceil(n / k)
counter = 0
while n > 0:
	counter += 1
	if counter % t == 0:
		n -= k
	if counter > d:
		if (counter - d) % t == 0:
			n -= k
if counter >= one_oven:
	print('NO')
else:
	print('YES')


import math
(n, t, k, d) = map(int, input().split())
if n <= k:
	print('NO')
elif d < (math.ceil(n / k) - 1) * t:
	print('YES')
else:
	print('NO')


from __future__ import division, print_function
MOD = 998244353
mod = 10 ** 9 + 7
import sys

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def input():
	return sys.stdin.readline().strip()

def main():
	(n, t, k, d) = get_ints()
	x = (d // t + 1) * k < n
	if x:
		print('YES')
	else:
		print('NO')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import math
input = [int(x) for x in input().split()]
g = math.ceil(input[0] / input[2])
singleOven = g * input[1]
o1 = 0
o2 = input[3]
for i in range(g):
	if o1 <= o2:
		o1 += input[1]
	else:
		o2 += input[1]
if max(o1, o2) < singleOven:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split())
result = 'NO'
if n % k == 0:
	i = n // k
else:
	i = n // k + 1
one = i * t
f = 0
while i > 0 and f <= d:
	f += t
	i -= 1
f += t * math.floor(i / 2)
s = d
s += t * round(i / 2)
both = max(s, f)
if both < one:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split())
(n1, t1, k1, d1) = (n, t, k, d)
b1 = 0
b2 = d
curr = 0
while n1 > 0 or b1 > 0 or b2 > 0:
	if b1 == 0:
		if n1 > 0:
			n1 -= k1
			b1 += t
	if b2 == 0:
		if n1 > 0:
			n1 -= k1
			b2 += t
	b1 -= 1
	b2 -= 1
	curr += 1
curr2 = int(ceil(n / k)) * t
if curr < curr2:
	print('YES')
else:
	print('NO')


def oven_needed(n, t, k, d):
	time_passed = 0
	oven_needed = 'NO'
	while n > 0:
		time_passed += t
		n = n - k
		if n > 0 and time_passed > d:
			return 'YES'
	return oven_needed
(n, t, k, d) = map(int, input().split())
print(oven_needed(n, t, k, d))


a = list(map(int, input().split()))
n = a[0]
t = a[1]
k = a[2]
d = a[3]
import math
count_1 = math.ceil(n / k) * t
count_2 = d + t
if count_1 > count_2:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split())
time_one_oven = ceil(n / k) * t
cakes_while_building_new_oven = ceil(d / t) * k
remaining_cakes = n - cakes_while_building_new_oven
if remaining_cakes < 0:
	remaining_cakes = 0
time_two_ovens = d + max(ceil(cakes_while_building_new_oven / k) * t - d, ceil(remaining_cakes / (2 * k)) * t)
if time_two_ovens < time_one_oven:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
time1 = (n + k - 1) // k * t
(ta, tb) = (0, d)
while n > 0:
	if ta <= tb:
		ta += t
	else:
		tb += t
	n -= k
time2 = max(ta, tb)
if time1 > time2:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = [int(x) for x in input().split()]
total_time_1 = math.ceil(n / k) * t
total_time_2 = d
cakes_remaining = n
rounds_before_oven = math.floor(d / t)
cakes_remaining = n - rounds_before_oven * k
while cakes_remaining > 0:
	cakes_remaining -= k * 2
	total_time_2 += t
if k >= n:
	print('NO')
elif d >= total_time_1:
	print('NO')
elif total_time_1 <= total_time_2:
	print('NO')
else:
	print('YES')


def bp1(time):
	return time // t * k

def bp2(time):
	return time // t * k + max(time - d, 0) // t * k
(n, t, k, d) = map(int, input().split())
l = 0
r = 10 ** 9
while l < r - 1:
	m = (l + r) // 2
	if bp1(m) >= n:
		r = m
	else:
		l = m
ans1 = r
l = 0
r = 10 ** 9
while l < r - 1:
	m = (l + r) // 2
	if bp2(m) >= n:
		r = m
	else:
		l = m
ans2 = r
if ans2 < ans1:
	print('YES')
else:
	print('NO')


(n, t, k, l) = map(int, input().split())
if k >= n and t <= l:
	print('NO')
else:
	while True:
		h = l - t
		y = n - k
		if h < 0:
			if y > 0:
				print('YES')
				break
			else:
				print('NO')
				break
		elif h == 0:
			if y <= k:
				print('NO')
				break
			else:
				print('YES')
				break
		elif h > 0:
			o = n
			for i in range(t, l + 1, t):
				o -= k
				if o <= 0:
					print('NO')
					break
			else:
				if o <= k:
					print('NO')
					break
				else:
					print('YES')
					break
			break


def sing(n, t, k):
	have = 0
	q = [t]
	last = 0
	while have < n:
		last = q[0]
		q.append(q[0] + t)
		q = q[1:]
		have += k
		q.sort()
	return last

def getdouble(n, t, k, d):
	have = 0
	q = [t, d + t]
	last = 0
	while have < n:
		last = q[0]
		q.append(q[0] + t)
		q = q[1:]
		have += k
		q.sort()
	return last

def main():
	(n, t, k, d) = list(map(int, input().split()))
	single = (n + k - 1) // k
	single *= t
	single = sing(n, t, k)
	double = getdouble(n, t, k, d)
	print('YES' if double < single else 'NO')
main()


(n, t, k, d) = map(int, input().split())
c = (n + k - 1) // k * t
x = c - d
b1 = (x - 1) // t * k
b2 = (c - 1) // t * k
if b1 + b2 >= n:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
time_One_Oven = n // k * t if n % k == 0 else (n // k + 1) * t
time_Two_Oven = 0
cakes = 0
delta_t = [0, d]
while cakes < n:
	if delta_t[0] < delta_t[1]:
		delta_t[0] += t
		time_Two_Oven = delta_t[0]
		cakes += k
	if delta_t[1] < delta_t[0]:
		delta_t[1] += t
		time_Two_Oven = delta_t[1]
		cakes += k
	if delta_t[0] == delta_t[1]:
		delta_t[0] += t
		delta_t[1] += t
		time_Two_Oven = delta_t[0]
		cakes += 2 * k
print('YES' if time_Two_Oven < time_One_Oven else 'NO')


def main(cake, cooking_time, group, build):
	single = cake // group
	if cake % group:
		single += 1
	single *= cooking_time
	if single <= build + cooking_time:
		return 'NO'
	return 'YES'
(a, b, c, d) = map(int, input().split())
res = main(a, b, c, d)
print(res)


(n, t, k, d) = list(map(int, input().split()))
if n % k != 0:
	n -= n % k
	n += k
t1 = n / k * t
t2 = t + d
if t2 < t1:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = input().split()
res = 'NO'
if int(n) > int(k):
	totaltime = int(t) * math.ceil(int(n) / int(k))
	if totaltime > int(d) + int(t):
		res = 'YES'
print(res)


(n, t, k, d) = map(int, input().split())
if n % k == 0:
	before = n / k * t
else:
	before = n / k * t + t
if k >= n:
	print('NO')
else:
	if d >= t:
		x = int(d / t) * k
		x = n - x
		if x <= k:
			after = before
		else:
			after = x / k * (t / 2) + d
	else:
		after = n / k * (t / 2) + d
	if before <= after:
		print('NO')
	else:
		print('YES')


import math

def main():
	(a, b, c, d) = map(int, input().split())
	if math.ceil(a / c) * b > b + d:
		print('YES')
	else:
		print('NO')
main()


from heapq import *
from math import ceil

def solution(n, t, k, d):
	cakes = [0]
	time = 0
	pq = []

	def bakeCakes():
		cakes[0] += k
		heappush(pq, (time + t, 'bakeCakes'))

	def makeOven():
		heappush(pq, (time + t, 'bakeCakes'))
	heappush(pq, (time + d, 'makeOven'))
	heappush(pq, (time + t, 'bakeCakes'))
	while cakes[0] < n:
		event = heappop(pq)
		time = event[0]
		if event[1] == 'bakeCakes':
			bakeCakes()
		elif event[1] == 'makeOven':
			makeOven()
	return ceil(n / k) * t > time
(n, t, k, d) = map(int, input().split())
print('YES' if solution(n, t, k, d) else 'NO')


while True:
	try:
		(n, t, k, d) = map(int, input().split())
		from math import ceil
		print('YES' if ceil(n / k) * t > t + d else 'NO')
	except EOFError:
		break


from math import ceil
(N, T, K, D) = [int(x) for x in input().split()]
Groups = ceil(N / K)
O1 = 0
O2 = D
for i in range(Groups):
	if O1 < O2:
		O1 += T
	else:
		O2 += T
if max(O1, O2) < Groups * T:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
g = int((n + k - 1) / k)
(o1, o2) = (0, d)
i = 0
while i < g:
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
	i += 1
if max(o1, o2) < g * t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
a = -(-n // k) * t
(nt1, nt2, c) = (0, 0, 0)
r = k / t
t1 = 0
ns = 0
while ns < n or c == False:
	if t1 >= d:
		nt1 += r
		nt2 += r
	else:
		nt1 += r
	if nt1 >= k:
		ns += k
		nt1 = 0
		if ns >= n:
			t1 += 1
			break
	if nt2 >= k:
		ns += k
		nt2 = 0
		c = 1
	t1 += 1
if a <= t1 - 1 or not c:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
if n % k != 0:
	n -= n % k
	n += k
tiempo1estufa = n / k * t
tiempo2estufas = t + d
if tiempo2estufas < tiempo1estufa:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split())
a = ceil(n / k) * t
u = 0
tr = 0
while u < n:
	if tr % t == 0 and tr:
		u += k
	if tr - d > 0 and (tr - d) % t == 0:
		u += k
	tr += 1
tr -= 1
if a > tr:
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(x) for x in input().split(' ')]
time1 = n // k * t
if n % k != 0:
	time1 = time1 + t
a = 0
b = d
while n > 0:
	if a < b:
		a = a + t
	else:
		b = b + t
	n = n - k
time2 = max(a, b)
if time1 > time2:
	print('Yes')
else:
	print('No')


(n, t, k, d) = map(int, input().split())
from math import ceil
t1 = ceil(n / k) * t
tektime = 0
p1 = 0
p2 = -d
while n > 0:
	p1 += 1
	p2 += 1
	if p1 == t:
		n -= k
		p1 = 0
	if p2 == t:
		n -= k
		p2 = 0
	tektime += 1
if t1 > tektime:
	print('YES')
else:
	print('NO')


en = input().split(' ')
n = int(en[0])
t = int(en[1])
k = int(en[2])
d = int(en[3])
if int(d / t) * k + k < n:
	print('YES')
else:
	print('NO')


import math
inputes = list(map(int, input().split()))
rownd = math.ceil(inputes[0] / inputes[2])
if rownd == 1:
	if inputes[1] <= inputes[3] or inputes[1] >= inputes[3]:
		print('NO')
elif rownd > 1:
	time1 = rownd * inputes[1]
	time2 = inputes[1] + inputes[3]
	if time1 > time2:
		print('YES')
	else:
		print('NO')


import sys
(n, t, k, d) = map(int, input().split(' '))
if k >= n:
	print('NO')
	exit()
elif t > d:
	print('YES')
	exit()
elif t <= d:
	if d + t < t * ((n + k - 1) // k):
		print('YES')
		exit()
	else:
		print('NO')
		exit()


import math
(n, t, k, d) = map(int, input().split())
total_time = math.ceil(n / k) * t
if total_time - t > d:
	print('Yes')
else:
	print('No')


(n, t, k, d) = list(map(int, input().split()))
from math import floor, ceil
t1 = ceil(n / k) * t
if n - floor(d / t) * k <= 0:
	t2 = t1
else:
	t2 = ceil((n - floor(d / t) * k) / (2 * k)) * t + d
if t2 < t1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(x) for x in input().split()]
c = n // k + (n % k > 0)
print('YES' if (c - 1) * t > d else 'NO')


(N, T, K, D) = input().split(' ')
(n, t, k, d) = (int(N), int(T), int(K), int(D))
T1 = int(d / t) * k
T2 = n - k
print('YES') if T1 < T2 else print('NO')


(n, t, k, d) = map(int, input().rstrip().split())
if k >= n:
	print('NO')
elif n > (t + d) // t * k:
	print('YES')
else:
	print('NO')


S = input()
(a, b, c, d) = S.split(' ')
a = int(a)
b = int(b)
c = int(c)
d = int(d)
if (b + d) // b * c < a:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split())
o1 = math.ceil(n / k) * t
i = 1
while i * t < d:
	i += 1
n -= i * k
o2 = math.ceil(n / 2 / k) * t + d
print('YES' if o2 < o1 and n > 0 else 'NO')


import math
(n, t, k, d) = map(int, input().split())
if k >= n:
	print('NO')
else:
	aux = n / k
	i = math.ceil(aux)
	OGtime = i * t
	contPast = 0
	time = 0
	cont = d
	while contPast < n:
		time += 1
		if time % t == 0:
			contPast += k
		if cont == 0:
			contPast += k
			k *= 2
		if contPast > 0:
			cont -= 1
	if time < OGtime:
		print('YES')
	else:
		print('NO')


def main():
	(n, t, k, d) = map(int, input().split())
	print(('NO', 'YES')[d < (n - 1) // k * t])
main()


from math import *
from collections import *
import sys
sys.setrecursionlimit(10 ** 9)
mod = 10 ** 9 + 7
(n, t, k, d) = map(int, input().split())
if k >= n:
	print('NO')
else:
	s = d // t * k
	if s < n - k:
		print('YES')
	else:
		print('NO')


import math
variables = input().split(' ')
variables = [int(item) for item in variables]
without_second_oven = math.ceil(variables[0] / variables[2]) * variables[1]
t = variables[2] / variables[1]
(libre1, libre2) = (0, variables[3])
(isLibre1, isLibre2) = (False, False)
counter = 999999999999999
n = variables[0]
for x in range(1, without_second_oven + 1):
	if libre1 == 0:
		if n > 0:
			n -= variables[2]
			libre1 = libre1 + variables[1]
		else:
			isLibre1 = True
	if libre2 == 0:
		if n > 0:
			n -= variables[2]
			libre2 = variables[1]
		else:
			isLibre2 = True
	libre1 -= 1
	libre2 -= 1
	if isLibre1 and isLibre2:
		break
	counter = x
if without_second_oven <= counter:
	print('NO')
else:
	print('YES')


(n, t, k, d) = [int(x) for x in input().split()]
x = int(d / t) + 1
x = x * k
rest = n - x
if rest >= 1:
	print('YES')
else:
	print('NO')


def main():
	(n, t, k, d) = list(map(int, input().split()))
	method_a = (n + k - 1) // k * t
	done = 0
	i = 0
	a_progress = b_progress = 0
	while done < n:
		a_progress += 1
		if a_progress == t:
			a_progress = 0
			done += k
		if d > 0:
			d -= 1
		else:
			b_progress += 1
			if b_progress == t:
				b_progress = 0
				done += k
		i += 1
	print('YES' if i < method_a else 'NO')
try:
	while True:
		main()
except EOFError:
	pass


(n, t, k, d) = map(int, input().split())
bakes = -(-n // k)
oneOven = t * bakes
m = float('Inf')
for i in range(0, bakes + 1):
	m = min(m, max(t * i, d + t * (bakes - i)))
if m < oneOven:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
o1 = 0
o2 = d
m = (n + k - 1) // k
for x in range(m):
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
if m * t > max(o1, o2):
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = list(map(int, input().split()))
time = t * math.ceil(n / k)
cnt = ((time - 1) // t + max(0, time - 1 - d) // t) * k
print('YES' if cnt >= n else 'NO')


[n, t, k, d] = list(map(int, input().split()))
tim = t * (n // k)
if n % k != 0:
	tim += t
if d < tim - t:
	ans = 'YES'
else:
	ans = 'NO'
print(ans)


(n, t, k, d) = map(int, input().split())
x = 0
new_t = 0
while d >= new_t:
	new_t += t
	x += k
if x >= n:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
if d / t < 1:
	if n - k > 0:
		print('YES')
	elif n - k <= 0:
		print('NO')
else:
	from math import ceil
	if n - ceil(d / t) * k <= k and (ceil(d / t) + 1) * t <= d + t or n - ceil(d / t) * k <= 0:
		print('NO')
	else:
		print('YES')


(n, t, k, d) = map(int, input().split())
first = n // k
if n % k != 0:
	first += 1
first = first * t
left = -1
right = int(1000000000.0)
while right - left > 1:
	mid = (left + right) // 2
	one = mid // t * k
	two = max(mid - d, 0) // t * k
	if one + two >= n:
		right = mid
	else:
		left = mid
if right != first:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = [int(x) for x in input().split()]
totaltimeforn = int(math.ceil(n / k) * t) - t
if d < totaltimeforn:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
num = (n + k - 1) // k
o1 = 0
o2 = d
for i in range(num):
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
if max(o1, o2) < num * t:
	print('YES')
else:
	print('NO')


import sys
input = sys.stdin.readline
import math

def inpit():
	return int(input())

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

def inpstr():
	s = input()
	return list(s[:len(s) - 1])

def inpspit():
	return map(int, input().split())
(n, t, k, d) = inpspit()
a = math.ceil(n / k) * t
i = 1
j = 1
while True:
	d = d + t * i
	j = j + math.ceil(d / t) + 1
	i = i + 1
	if n <= j * k:
		if a > d:
			print('YES')
			break
		else:
			print('NO')
			break


def decider(n, t, k, d):
	time_counter = 0
	cake_counter = 0
	while cake_counter < n:
		time_counter += 1
		if time_counter % t == 0 and time_counter != 0:
			cake_counter += k
	time_counter_2 = 0
	cake_counter_2 = 0
	while cake_counter_2 < n:
		time_counter_2 += 1
		if time_counter_2 % t == 0 and time_counter != 0:
			cake_counter_2 += k
		if time_counter_2 > d and (time_counter_2 - d) % t == 0:
			cake_counter_2 += k
	if time_counter_2 < time_counter:
		return 'YES'
	else:
		return 'NO'
(n, t, k, d) = map(int, input().split())
print(decider(n, t, k, d))


(n, t, k, d) = (int(x) for x in input().split(' '))
time1 = n // k * t
if n % k != 0:
	time1 = time1 + t
(a, b) = (0, d)
while n > 0:
	if a < b:
		a = a + t
	else:
		b = b + t
	n = n - k
time2 = max(a, b)
if time1 > time2:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split())
without = t * ceil(n / k)
(c, t1, t2) = (0, 0, 0)
while c < n:
	t1 += 1
	if t1 > d:
		t2 += 1
	if t1 % t == 0:
		c += k
	if t2 % t == 0 and t2 != 0:
		c += k
if t1 < without:
	print('YES')
else:
	print('NO')


def CarrotCakes():
	(n, t, k, d) = [*map(int, input().strip().split())]
	if n <= k:
		return 'NO'
	elif d == t:
		return 'YES' if n - k > k else 'NO'
	elif d < t:
		return 'YES'
	else:
		return 'YES' if n - d // t * k > k else 'NO'
a = CarrotCakes()
print(a)


(n, t, k, d) = map(int, input().split())
(x, c1, c2, t1, t2) = (0, 0, 0, 1, 1)
while c1 < n:
	if t1 % t == 0:
		c1 += k
	t1 += 1
while c2 < n:
	if t2 % t == 0:
		c2 += k
	if t2 > d and (t2 - d) % t == 0:
		c2 += k
	t2 += 1
print('YES' if t1 > t2 else 'NO')


x = [int(x) for x in input().split(' ')]
n = int((x[0] + (x[2] - 1)) / x[2])
o1 = 0
o2 = x[3]
for i in range(n):
	if o1 <= o2:
		o1 += x[1]
	else:
		o2 += x[1]
if max(o1, o2) < n * x[1]:
	print('YES')
else:
	print('NO')


import math
(nr_prajituri, t_set, nr_acelasi_timp, t_cuptor) = input().split()
nr_prajituri = int(nr_prajituri)
t_set = int(t_set)
nr_acelasi_timp = int(nr_acelasi_timp)
t_cuptor = int(t_cuptor)
t1 = math.ceil(nr_prajituri / nr_acelasi_timp) * t_set
t2 = 2
if t_set > t_cuptor:
	t2 = math.ceil(math.ceil(nr_prajituri / 2) / nr_acelasi_timp) * t_set
if t_set == t_cuptor:
	t2 = t_set + math.ceil((nr_prajituri - nr_acelasi_timp) / (nr_acelasi_timp * 2)) * t_set
if t_set < t_cuptor:
	intretimp = t_cuptor / t_set * nr_acelasi_timp
	t2 = t_cuptor + math.ceil(math.ceil((nr_prajituri - intretimp) / 2) / nr_acelasi_timp) * t_set
if t1 <= t2:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
time2 = d
time1 = 0
a = 0
while n > 0:
	time1 += t
	n -= k
if d + t >= time1:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
i = 0
baked = 0
used = False
while baked < n:
	i += 1
	if i % t == 0:
		baked += k
	if i > d and (i - d) % t == 0:
		used = used or baked < n
		baked += k
print('YES' if used else 'NO')


import math

def computeWithOneOven(n, t, k):
	return t * int(math.ceil(n / k))

def computeWithTwoOvens(n, t, k, d):
	oven1Time = 0
	oven2Time = -d
	currTime = 0
	totCakes = 0
	while totCakes < n:
		if oven1Time > 0 and oven1Time % t == 0:
			totCakes += k
		if oven2Time > 0 and oven2Time % t == 0:
			totCakes += k
		if totCakes >= n:
			return currTime
		oven1Time += 1
		oven2Time += 1
		currTime += 1
	return currTime
(n, t, k, d) = [int(x) for x in input().split()]
timeWithOneOven = computeWithOneOven(n, t, k)
timeWithTwoOvens = computeWithTwoOvens(n, t, k, d)
if timeWithTwoOvens < timeWithOneOven:
	print('YES')
else:
	print('NO')


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
d = defaultdict(int)
(n, t, k, d) = M()
x = mt.ceil(n / k)
totaltime = x * t
if totaltime > d + t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().strip().split())
sum1 = 0
sum2 = 0
if n % k == 0:
	sum1 = int(n / k)
else:
	sum1 = int(n / k) + 1
time1 = sum1 * t
num1 = int(d / t)
num2 = d % t
if (n - k * num1) % (2 * k) == 0:
	sum2 = int((n - k * num1) / (2 * k))
else:
	sum2 = int((n - k * num1) / (2 * k) + 1)
time2 = d + sum2 * t
if time1 > time2:
	print('YES')
else:
	print('NO')


nums = list(map(int, input().split()))
curr_time = 0
oven_time = nums[3]
while curr_time <= oven_time:
	nums[0] -= nums[2]
	curr_time += nums[1]
if nums[0] > 0:
	print('YES')
else:
	print('NO')


def ceil_div(x, y):
	buff = x // y
	if buff * y < x:
		return buff + 1
	return buff

def main():
	inp = input().split()
	(n, t, k, d) = (int(inp[0]), int(inp[1]), int(inp[2]), int(inp[3]))
	time1 = ceil_div(n, k) * t
	if time1 - d > t:
		print('YES')
		return
	print('NO')
	return
main()


list = input().split()
n = int(list[0])
t = int(list[1])
k = int(list[2])
d = int(list[3])
once = True
over = False
cakesBaked = 0
timeTaken = 0
cyclesTaken = 0
cyclesMarker = 0
while cakesBaked < n:
	timeTaken += t
	cyclesTaken += 1
	cakesBaked += k
	if timeTaken > d and once:
		cyclesMarker = cyclesTaken
		once = False
		over = True
	if timeTaken == d and once:
		cyclesMarker = cyclesTaken
		once = False
if cyclesTaken - cyclesMarker >= 2 and cyclesMarker != 0 or (cyclesTaken - cyclesMarker == 1 and over):
	print('YES')
else:
	print('NO')


import math as m
(n, t, k, d) = map(int, input().split())
(first, count) = (m.ceil(n / k) * t, 0)
while n > 0:
	count += 1
	if count % t == 0:
		n -= k
	if (count - d) % t == 0 and count > d:
		n -= k
print('YNEOS'[first <= count::2])


(n, t, k, d) = map(int, input().split())
l = (n + k - 1) // k
(x, y) = (0, d)
for i in range(l):
	if x <= y:
		x += t
	else:
		y += t
if max(x, y) < l * t:
	print('YES')
else:
	print('NO')


[n, t, k, d] = list(map(int, input().split()))
t1 = (n + k - 1) // k * t
t2 = 0
for x in range(d, 1000007, 1):
	cnt = 0
	cnt += x // t * k
	cnt += (x - d) // t * k
	if cnt >= n:
		t2 = x
		break
if t1 > t2:
	print('YES')
else:
	print('NO')


a = list(map(int, input().split()))

def dur(total, cake_t, time):
	x = total / cake_t
	if int(x) == x:
		return x * time
	else:
		return (int(x) + 1) * time
print('YES') if dur(a[0], a[2], a[1]) - a[1] > a[3] else print('NO')


import math
(n, t, k, d) = list(map(int, input().split()))
one = math.ceil(n / k)
second = math.floor(d / t)
if one - second > 1:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split())
T1 = ceil(n / k) * t
C2 = ceil(d / t) * k
n_rem = n - C2
if n_rem < 0:
	n_rem = 0
T2 = d + max(ceil(n_rem / (2 * k)) * t, ceil(C2 / k) * t - d)
if T1 > T2:
	print('YES')
else:
	print('NO')


s = input().split()
n = int(s[0])
t = int(s[1])
k = int(s[2])
d = int(s[3])
time = 0
ok = 0
while n > 0:
	if d < time:
		ok = 1
		break
	time += t
	n -= k
if ok:
	print('YES')
else:
	print('NO')


def ceiling(n):
	if n == int(n):
		return int(n)
	else:
		return int(n) + 1
(n, t, k, d) = input().split()
n = int(n)
t = int(t)
k = int(k)
d = int(d)
t_one_oven = ceiling(n / k) * t
t_two_ovens = 0
total_cooked = 0
second_oven = False
while 1:
	if t_two_ovens != 0 and t_two_ovens % t == 0:
		total_cooked += k
	if t_two_ovens == d:
		second_oven = True
	if second_oven == True and (t_two_ovens - d) % t == 0 and (t_two_ovens != d):
		total_cooked += k
	if total_cooked >= n:
		break
	else:
		t_two_ovens += 1
if t_two_ovens < t_one_oven:
	print('YES')
else:
	print('NO')


(n, t, k, d) = (int(i) for i in input().split())
t1 = 0
k1 = 0
while k1 < n:
	k1 += k
	t1 += t
t2 = 0
k2 = 0
c = 0
while k2 < n:
	if c % t == 0 and c > 0:
		k2 += k
	if c - d > 0 and (c - d) % t == 0:
		k2 += k
	c += 1
c -= 1
if t1 > c:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
p = d // t * k
if n - p > k:
	print('YES')
else:
	print('NO')


from math import ceil, floor
(n, t, k, d) = list(map(int, input().split()))
t1 = ceil(n / k) * t
t1d = floor(d / t) * k
if t1d + k >= n:
	print('NO')
else:
	print('YES')


(n, t, k, d) = list(map(int, input().strip().split()))
x = int((n + k - 1) / k) - 1
if x * t > d:
	print('YES')
else:
	print('NO')


s = input()
s = [int(i) for i in s.split()]
n = s[0] / s[2]
y = int(n)
if y == n:
	y1 = y
else:
	y1 = y + 1
x1 = y1 * s[1]
x2 = s[3] + s[1]
if x2 < x1:
	print('YES')
else:
	print('NO')


from sys import stdin
inp = iter([int(x) for x in stdin.read().split()])
n = next(inp)
t = next(inp)
k = next(inp)
d = next(inp)
ceil = lambda a, b: a // b if a % b == 0 else a // b + 1
min_one_oven = ceil(n, k) * t
num_cakes_cooked_first_oven = d // t * k + ceil(n - d // t * k, 2)
num_cakes_cooked_second_oven = n - num_cakes_cooked_first_oven
min_two_ovens = max(ceil(num_cakes_cooked_first_oven, k) * t, d + ceil(num_cakes_cooked_second_oven, k) * t)
if min_two_ovens < min_one_oven:
	print('YES')
else:
	print('NO')


def khong(n, t, k, d):
	return (int((n - 1) / k) + 1) * t

def co(n, t, k, d):
	l = int(0)
	r = 1500000
	while r - l > 1:
		mid = int((l + r) / 2)
		h1 = int(mid / t) * k + int((mid - d) / t) * k
		if h1 >= n:
			r = mid
		else:
			l = mid
	return r
(n, t, k, d) = map(int, input().split())
if co(n, t, k, d) < khong(n, t, k, d):
	print('YES')
else:
	print('NO')


str0 = [int(i) for i in input().split()]
n = str0[0]
t = str0[1]
k = str0[2]
d = str0[3]
baked = n
t1 = 0
while True:
	if baked < k:
		baked = 0
		t1 += t
	else:
		t1 += t
		baked -= k
	if baked == 0:
		break
t21 = 0
t22 = 1000000000000000
baked1 = 0
baked2 = 0
bakers = 1
while True:
	if k >= n:
		t22 = 1000000000000000000000
		break
	t21 += t
	baked1 += k
	if baked1 + baked2 >= n:
		break
	if t21 >= d:
		t22 = d
		t22 += t
		baked2 += k
		if baked1 + baked2 >= n:
			break
if t22 < t1:
	print('YES')
else:
	print('NO')


import sys

def solve():
	(n, t, k, d) = map(int, input().split())
	t1 = (n + k - 1) // k * t
	rest = n - d // t * k
	rest = (rest + k - 1) // k
	rem = d - d // t * t
	if rest % 2 == 0:
		t2 = d // t * t + rest // 2 * t + rem
	else:
		t2 = d // t * t + (rest + 1) // 2 * t
	dif = t1 - t2
	if dif > 0:
		ans = 'YES'
	else:
		ans = 'NO'
	print(ans)
solve()


(n, t, k, d) = map(int, input().split())

def tm(n, t, k, d):
	when = False
	time = 0
	timed = 0
	while n > 0:
		if time >= d:
			when = True
		if when == True:
			if time % t == 0 and time != 0:
				n -= k
			if timed % t == 0 and timed != 0:
				n -= k
			timed += 1
		elif time % t == 0 and time != 0:
			n -= k
		if n <= 0:
			break
		time += 1
	return time

def tmn(n, t, k, d):
	when = False
	time = 0
	timed = 0
	while n > 0:
		if time >= d:
			when = True
		if time % t == 0 and time != 0:
			n -= k
		if n <= 0:
			break
		time += 1
	return time
if tm(n, t, k, d) < tmn(n, t, k, d):
	print('YES')
else:
	print('NO')


import math
arr = list(map(int, input().split()))
n = arr[0]
t = arr[1]
k = arr[2]
d = arr[3]
tno = math.ceil(n / k) * t
if d + t < tno:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().strip().split(' ')))
old = 0
total = 0
time1 = 0
while total < n:
	if time1 % t == 0 and time1 > 0:
		total += k
	time1 += 1
old = time1
total = 0
time1 = 0
time2 = 0
check = 0
while total < n:
	if time1 % t == 0 and time1 > 0:
		total += k
		if time1 > d and check == 0:
			check = 1
			start = time1
	if check == 1 and (time2 - start) % t == 0:
		total += k
	time1 += 1
	time2 += 1
if time1 < old:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = tuple(list(map(int, input().split(' '))))
if k > n:
	print('NO')
else:
	iters = ceil(n / float(k))
	time = iters * t
	num2 = int(float(d) / t) * k
	time2 = d
	while num2 < n:
		num2 += 2 * k
		time2 += t
	if time2 < time:
		print('YES')
	else:
		print('NO')


import sys
it = iter(sys.stdin.read().splitlines())
(n, t, k, d) = [int(x) for x in next(it).split()]
m = d // t
print('YES ') if k * m < n - k else print('NO')


(n, t, k, d) = map(int, input().split())
one_p = (n // k + (n % k != 0)) * t
two_p = 1
cooked = 0
while 1:
	if two_p % t == 0:
		cooked += k
	if two_p > d and (two_p - d) % t == 0:
		cooked += k
	if cooked >= n:
		break
	two_p += 1
if two_p < one_p:
	print('Yes')
else:
	print('No')


import math
(n, t, k, d) = [int(x) for x in input().split()]
if k >= n:
	print('NO')
else:
	r1 = math.ceil(n / k) * t
	r2 = d + math.ceil((n - d // t * k) / (2 * k)) * t
	if r2 < r1:
		print('YES')
	else:
		print('NO')


oven1 = 0
t_oven1 = 0
oven2 = 0
t_oven2 = 0
b = 0
all_time = 0
(n, t, k, d) = [int(z) for z in input().split()]
if 1 <= n <= 1000 and 1 <= t <= 1000 and (1 <= k <= 1000) and (1 <= d <= 1000):
	for z in range(n + 1):
		if oven1 < n:
			oven1 = oven1 + k
			t_oven1 = t_oven1 + t
	oven11 = 0
	t_oven11 = 0
	eee = 0
	eef = 0
	for s in range(n):
		if eef < d:
			eee = eee + k
			eef = eef + t
			if eef > d:
				eef = eef - (eef - d)
	for x in range(n + 1):
		if b < n:
			oven2 = oven2 + k
			t_oven2 = t_oven2 + t
			oven11 = oven11 + k
			t_oven11 = t_oven11 + t
			b = oven11 + oven2 + eee
			all_time = t_oven2 + eef
	if t_oven1 <= all_time:
		print('NO')
	else:
		print('YES')


import math
L = list(map(int, input().split()))
n = L[0]
t = L[1]
k = L[2]
d = L[3]
out = 'NO'
r = math.ceil(n / k)
if r > 1:
	if t > d:
		out = 'YES'
	else:
		count = 0
		for i in range(r):
			if count > d:
				out = 'YES'
			count += t
print(out)


(n, t, k, d) = map(int, input().split())
a = n
a1 = int(n / k + 0.9999) * t
a2 = d
if t <= d:
	n -= d // t * k
if n <= 0:
	print('NO')
	exit(0)
while n > 0:
	n = n - 2 * k
	a2 += t
if a1 > a2:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
clk = 0
s = 0
while s < n:
	s += k
	clk += t
clk2 = 0
(lb, ub) = (0, int(10000000000.0))
while lb <= ub:
	mid = lb + ub >> 1
	s = mid // t * k + max(0, mid - d) // t * k
	if s >= n:
		clk2 = mid
		ub = mid - 1
	else:
		lb = mid + 1
print(['NO', 'YES'][clk > clk2])


(n, t, k, d) = map(int, input().split())
u = 0 - -n // k
u -= d // t + 1
print('YNEOS'[u <= 0::2])


(n, t, k, d) = [int(x) for x in input().split(' ')]
t1 = 0
t2 = 0
if n % k == 0:
	t1 = n // k * t
else:
	t1 = (n // k + 1) * t
c = 0
while c < n:
	t2 += 1
	if t2 % t == 0:
		c += k
	if t2 - d > 0 and (t2 - d) % t == 0:
		c += k
if t2 < t1:
	print('YES')
else:
	print('NO')


3

def time1(n, t, k):
	return (n + k - 1) // k * t

def num2(T, t, k, d):
	return T // t * k + max(0, (T - d) // t) * k

def time2(n, t, k, d):
	(l, r) = (0, 10 ** 18)
	while l < r - 1:
		mid = (l + r) // 2
		if num2(mid, t, k, d) < n:
			l = mid
		else:
			r = mid
	return r
(n, t, k, d) = list(map(int, input().split()))
if time1(n, t, k) <= time2(n, t, k, d):
	print('NO')
else:
	print('YES')


x = list(map(int, input().strip().split()))
n = x[0]
t = x[1]
k = x[2]
d = x[3]
res = n / k
if n % k > 0:
	res = int(n / k) + 1
if res * t - t > d:
	print('YES')
else:
	print('NO')


from sys import stdin, stdout
import math
from fractions import gcd

def sin():
	return stdin.readline().rstrip()

def listInput():
	return list(map(int, sin().split()))

def printBS(li):
	if not li:
		return
	for i in range(len(li) - 1):
		stdout.write('%d ' % li[i])
	stdout.write('%d\n' % li[-1])
(n, t, k, d) = listInput()
N = 10 ** 6 + 1
cakes2 = 0
i2 = 0
for i in range(1, N):
	if i % t == 0:
		cakes2 += k
	if cakes2 >= n:
		i2 = i
		break
cakes = 0
for i in range(1, N):
	if i % t == 0:
		cakes += k
	if d < i and (i - d) % t == 0:
		cakes += k
	if cakes >= n:
		if i >= i2:
			print('NO')
		else:
			print('YES')
		break


(n, t, k, d) = map(int, input().split())
ans1 = (n + k - 1) // k * t
ans2 = 1 << 30
for x in range(1, 1000010):
	if ((d + x) // t + x // t) * k >= n:
		ans2 = d + x
		break
if ans1 <= ans2:
	print('NO')
else:
	print('YES')


from math import floor, ceil
(n, t, k, d) = map(int, input().split())
ovenOne = 0
ovenTwo = 0
timeBuild = 0
while ovenOne + ovenTwo < n:
	timeBuild += 1
	if timeBuild % t == 0:
		ovenOne += k
	if timeBuild > d and (timeBuild - d) % t == 0:
		ovenTwo += k
timeNoBuild = ceil(n / k) * t
if timeBuild < timeNoBuild:
	print('YES')
else:
	print('NO')


L = input()
L = L.split()
n = int(L[0])
t = int(L[1])
k = int(L[2])
d = int(L[3])
cakes = 0
if n > k:
	time = n / k * t
	if time > n // k * t:
		time = (n // k + 1) * t
else:
	time = t
timenew = d
Aux = d // t
cakes += Aux * k
while cakes < n:
	cakes += 2 * k
	timenew += t
if timenew < time:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
res = n % k
tmp1 = n // k * t
if res > 0:
	tmp1 += t
if tmp1 <= d + t:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
z1 = z2 = z3 = 0
x = c = y = 0
while 1:
	x += k
	z1 += t
	if x >= n:
		break
c = int(d / t)
z2 = c * t
x = c * k
while 1:
	if x >= n:
		break
	else:
		x += 2 * k
		z2 += t
x = y = 0
z3 = d
while 1:
	x += 2 * k
	z3 += t
	if x >= n:
		break
if (z2 < z1) | (z3 < z1):
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().strip().split())
res = d // t
r = k + res * k
if r >= n:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
time = 0
n1 = 0
n2 = 0
while True:
	time += 1
	if time % t == 0:
		n1 += k
		n2 += k
	if time > d:
		if (time - d) % t == 0:
			n2 += k
	if n1 >= n:
		print('No')
		break
	if n2 >= n:
		print('Yes')
		break


(N, T, K, D) = input().split(' ')
(n, t, k, d) = (int(N), int(T), int(K), int(D))
g = int((n + k - 1) / k)
o1 = 0
o2 = d
for i in range(0, g):
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
T1 = max(o1, o2)
T2 = g * t
print('YES') if T1 < T2 else print('NO')


import math
(n, t, k, d) = map(int, input().split())
s1 = math.ceil(n / k) * t
c = 0
up = 1000 * t
down = 0
while up > down + 1:
	mid = (up + down) // 2
	c += mid // t * k
	c += (mid - d) // t * k
	if c >= n:
		up = mid
	else:
		down = mid
	c = 0
c = 0
if down // t * k + (down - d) // t * k == n:
	s2 = down
elif mid // t * k + (mid - d) // t * k == n:
	s2 = mid
else:
	s2 = up
if s2 < s1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split()))
pech1 = 0
pech2 = 0
pirog = 0
time1 = 0
time2 = 0
stroitel = False
while pech1 + pech2 < n:
	time1 += 1
	time2 += 1
	if time1 % t == 0:
		pech1 += k
		if stroitel:
			pech2 += k
	if time2 == d:
		stroitel = True
	if pech1 >= n and pech2 == k:
		pech2 = 0
if pech2 == 0:
	print('NO')
else:
	print('YES')


ntdk = input().strip().split(' ')
n = int(ntdk[0])
t = int(ntdk[1])
k = int(ntdk[2])
d = int(ntdk[3])
if n <= k:
	print('NO')
elif d < t:
	print('YES')
elif n - d // t * k > k:
	print('YES')
else:
	print('NO')


def bi_search(f, x):
	(left, right) = (0, 10 ** 9)
	while left + 1 < right:
		mid = (left + right) // 2
		if f(mid) >= x:
			right = mid
		else:
			left = mid
	return right
(N, T, K, D) = map(int, input().split())
if bi_search(lambda x: x // T * K, N) > bi_search(lambda x: x // T * K + max(0, (x - D) // T * K), N):
	print('YES')
else:
	print('NO')


from math import *
(n, t, k, d) = list(map(int, input().split()))
need = ceil(n / k) * t
need1 = t + d
if need > need1:
	print('YES')
else:
	print('NO')


n = [int(x) for x in input().split()]
t = 0
k = 0
t1 = 0
k1 = 0
for i in range(1000):
	t1 += n[1]
	k1 += n[2]
	if t1 > n[3]:
		k1 += n[2]
	t += n[1]
	k += n[2]
	if k >= n[0]:
		print('no')
		break
	elif k1 >= n[0]:
		print('yes')
		break


import math
(total_cakes, time_taken_k, k_carrot_cakes, oven_time) = map(int, input().split())
time1 = time_taken_k * math.ceil(total_cakes / k_carrot_cakes)
time2 = oven_time + time_taken_k
if time2 < time1:
	print('YES')
else:
	print('NO')


import math
while True:
	try:
		(n, t, k, d) = map(int, input().split())
		tim = math.ceil(n * 1.0 / k) * t
		dt = math.floor(d * 1.0 / t) * k
		lef = n - dt
		if lef > k:
			print('YES')
		else:
			print('NO')
	except EOFError:
		break


import math
import re
(n, t, k, d) = map(int, input().split())
if math.ceil(n / k) * t - d > t:
	res = 'YES'
else:
	res = 'NO'
print(res)


import math
(n, t, k, d) = map(int, input().split())
times = math.ceil(n / k)
totalWithOut = times * t
totalWith = t + d
if totalWith < totalWithOut:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split())
g = math.ceil(n / k)
(o1, o2) = (0, d)
for i in range(g):
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
if max(o1, o2) < g * t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
mult = n // k
if n % k >= 1:
	mult += 1
no = mult * t
yesCount = n
yes = d
yesCount -= d // t * k
while yesCount > 0:
	yesCount -= k * 2
	yes += t
if k >= n:
	print('NO')
elif no <= yes:
	print('NO')
else:
	print('YES')


import math
(n, t, k, d) = map(int, input().split())
baking_time = math.ceil(n / k) * t
for i in range(0, d + 1, t):
	n -= k
if n > 0:
	print('YES')
else:
	print('No')


(n, t, k, d) = map(int, input().split(' '))
N = (n + k - 1) // k
time1 = t * N
time2 = -1
while N > 0:
	time2 += 1
	if time2 % t == 0:
		N -= 1
	if time2 >= d and (time2 - d) % t == 0:
		N -= 1
time2 += t
if time2 < time1:
	print('YES')
else:
	print('NO')


input_ = list(map(int, input().split()))
counter = int((input_[0] + input_[2] - 1) / input_[2])
now = input_[3] / input_[1]
counter -= now
if counter <= 1:
	print('NO')
else:
	print('YES')


import math
ns = [int(i) for i in input().split()]
tm = math.ceil(ns[0] / ns[2])
tm *= ns[1]
if tm - ns[3] > ns[1]:
	print('YES')
else:
	print('NO')


import math
temp = input().split()
NumberOfCakes = int(temp[0])
TimeNeedToBakeKCakes = int(temp[1])
NumberOfCakesAtSameTime = int(temp[2])
TimeSecondOven = int(temp[3])

def fun1():
	NumberOfBakes = math.ceil(NumberOfCakes / NumberOfCakesAtSameTime)
	time1 = NumberOfBakes * TimeNeedToBakeKCakes
	return time1
time1 = fun1()
if TimeSecondOven + TimeNeedToBakeKCakes < time1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = input().split()
total = int(t) / int(k) * int(n)
o = int(int(d) / int(t)) * int(k)
if int(k) >= int(n):
	print('NO')
elif int(d) < int(t) and int(k) < int(n):
	print('YES')
elif int(d) >= int(t):
	if int(n) - int(o) > int(k):
		print('YES')
	else:
		print('NO')


(n, t, k, d) = map(int, input().split())
t2a = 0
t2b = d
t1 = (n + k - 1) // k * t
for i in range(int(t1 / t)):
	if t2a <= t2b:
		t2a += t
	else:
		t2b += t
if max(t2a, t2b) < t1:
	print('YES')
else:
	print('NO')


from sys import exit
(n, t, k, d) = map(int, input().split())
t1 = (n + k - 1) // k * t
t3 = 0
t2 = 0
n1 = 0
a = 0
while True:
	t3 += 1
	if a == 1:
		t2 += 1
		if t2 == t:
			n1 += k
	if d == t3:
		a = 1
	if t3 % t == 0:
		n1 += k
	if n1 >= n:
		break
if t1 <= t3:
	print('NO')
else:
	print('YES')


import os, io
from sys import stdout
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def binomial_coefficient(n, k):
	if 0 <= k <= n:
		ntok = 1
		ktok = 1
		for t in range(1, min(k, n - k) + 1):
			ntok *= n
			ktok *= t
			n -= 1
		return ntok // ktok
	else:
		return 0
(n, t, k, d) = list(map(int, input().split()))
n = n - k * (d // t)
if n > k:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
tempo = 0
bolos = 0
tempo2 = 0
bolos2 = 0
while bolos < n:
	tempo += t
	bolos += k
tempo2 += d
bolos2 += d // t * k
k += k
while bolos2 < n:
	tempo2 += t
	bolos2 += k
if tempo2 >= tempo:
	print('NO')
else:
	print('YES')


def cake():
	inp = list(map(int, input().strip().split()))
	n = inp[0]
	t = inp[1]
	k = inp[2]
	d = inp[3]
	x = int((n - 1) / k + 1)
	if t * x > t + d:
		return 'YES'
	else:
		return 'NO'
print(cake())


a = [int(i) for i in input().split()]
n = a[0]
t = a[1]
k = a[2]
d = a[3]
if n < k:
	print('NO')
else:
	timetakenby1 = n // k * t
	if n % k != 0:
		timetakenby1 += t
	if d > timetakenby1:
		print('NO')
	else:
		timetakenby2 = 0
		time = 1
		flag = 0
		while n > 0:
			if time % t == 0:
				n = n - k
			if flag == 1 and (time - d) % t == 0:
				n = n - k
			if time == d and flag == 0:
				flag = 1
			time += 1
		time -= 1
		if time >= timetakenby1:
			print('NO')
		else:
			print('YES')


from sys import maxsize, stdout, stdin, stderr
import re
tup = lambda : map(int, stdin.readline().split())
I = lambda : int(stdin.readline())
lint = lambda : [int(x) for x in stdin.readline().split()]
S = lambda : stdin.readline().replace('\n', '').strip()

def grid(r, c):
	return [lint() for i in range(r)]

def debug(*args, c=6):
	print('\x1b[3{}m'.format(c), *args, '\x1b[0m', file=stderr)
stpr = lambda x: stdout.write(f'{x}' + '\n')
star = lambda x: print(' '.join(map(str, x)))
from math import ceil
(n, t, k, d) = tup()
x = ceil(n / k) * t
c = 0
while c <= d:
	n -= k
	c += t
if n > 0:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split(' '))

def min_time_without(n, t, k):
	return (n + k - 1) // k * t

def min_time_with(n, t, k, d):
	q = 0
	ans = 0
	t1 = 0
	t2 = 0
	built = False
	while q < n:
		t1 += 1
		if built == True:
			t2 += 1
		ans += 1
		if ans == d:
			built = True
		if t1 == t:
			t1 = 0
			q += k
		if t2 == t and built == True:
			t2 = 0
			q += k
	return ans
if min_time_with(n, t, k, d) < min_time_without(n, t, k):
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split())
time_o = ceil(n / k) * t
if d + t >= time_o:
	print('NO')
else:
	print('YES')


from sys import stdin, stdout
from math import gcd, sqrt, floor, ceil
input = stdin.readline

def list_inp(x):
	return list(map(x, input().split()))

def map_inp(x):
	return map(x, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
(a, b, c, d) = map_inp(int)
ans = (d + b) // b * c
if ans < a:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
G = int((n + k - 1) / k)
case1 = G * t
(o1, o2) = (0, d)
for i in range(G):
	if o1 < o2:
		o1 += t
	else:
		o2 += t
case2 = max(o1, o2)
print('YES') if case2 < case1 else print('NO')


(n, t, k, d) = map(int, input().split())
z = k / t
a = 0
b = k / t * d
t1 = 0
t2 = d
while a < n:
	t1 += t
	a += k
while b < n:
	b += 2 * k
	t2 += t
if n < k:
	print('NO')
elif t1 <= t2:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
normal = (n + k - 1) // k * t
t1 = 0
t2 = d
time = 0
cakesBaked = 0
while cakesBaked < n:
	if t1 <= t2:
		t1 += t
		time = t1
		cakesBaked += k
	else:
		t2 += t
		time = t2
		cakesBaked += k
print('YES') if time < normal else print('NO')


from math import ceil
(n, t, k, d) = [int(i) for i in input().split()]
if ceil(n / k) * t <= d:
	print('NO')
else:
	extra = ceil(d / t)
	remain = n - extra * k
	if remain > 0:
		if remain <= k and d % t == 0:
			print('NO')
		else:
			print('YES')
	else:
		print('NO')


import math
N = input().split()
n = int(N[0])
t = int(N[1])
k = int(N[2])
d = int(N[3])
no_bakes = math.ceil(n / k)
oven1 = no_bakes * t
oven2 = float('inf')
times = math.ceil(d / t)
if d <= t:
	oven2 = no_bakes // 2 * t + d
elif no_bakes > times:
	if no_bakes >= 2:
		oven2 = (no_bakes - times + 1) // 2 * t + d
	else:
		oven2 = (no_bakes - times) // 2 * t + d + t
if oven1 > oven2 and no_bakes > 1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = (int(x) for x in input().split())
import math
if k >= n:
	print('NO')
else:
	t_1 = t * math.ceil(n / k)
	if d % t == 0:
		x = d / t
		m = x * k
		t_2 = x * t
		while m < n:
			t_2 += t
			m += 2 * k
	elif d < t:
		m = k
		t_2 = t
		while m < n:
			t_2 += d
			m += k
			if m < n:
				t_2 += t - d
				m += k
	elif d > t:
		x = d // t
		t_2 = (x + 1) * t
		m = (x + 1) * k
		while m < n:
			t_2 += d - x * t
			m += k
			if m < n:
				t_2 += (x + 1) * t - d
				m += k
	if t_1 > t_2:
		print('YES')
	else:
		print('NO')


x = list(map(int, input().rstrip().split()))
if x[0] <= x[2]:
	print('NO')
elif x[3] < x[1]:
	print('Yes')
else:
	mmkn = int(x[3] / x[1])
	cake_elmmkn = mmkn * x[2]
	elfadl = x[0] - cake_elmmkn
	if elfadl > x[2]:
		print('YES')
	else:
		print('NO')


(n, time, oven, newo) = map(int, input().split())
print('YES' if (newo // time + 1) * oven < n else 'NO')


(n, t, k, d) = map(int, input().split())
t1 = 0
a = n
while a > 0:
	a = a - k
	t1 += t
t2 = 0
o2 = 0
while True:
	t2 += 1
	if t2 % t == 0:
		n = n - k
	if o2 == 1 and (t2 - d) % t == 0:
		n = n - k
	if t2 == d:
		o2 = 1
	if n <= 0:
		break
if t2 < t1:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split())
MT = math.ceil(n / k)
M = 0
R = 0
i = 0
while i < n:
	M += 1
	R += t
	if R > d or t > d:
		R += t
		i += k
	i += k
if M < MT:
	print('YES')
else:
	print('NO')


import math
a = input()
a = a.split(' ')
a = [int(x) for x in a]
n = a[0]
t = a[1]
k = a[2]
d = a[3]
t1 = math.ceil(n / k) * t
if (t1 - d) / t > 1:
	print('YES')
else:
	print('NO')


def ceil(a, b):
	return (a + b - 1) // b
(n, t, k, d) = map(int, input().split())
v1 = ceil(n, k) * t
if v1 <= d + t:
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
current_time = 0
cakes_baked = 0
while current_time <= d:
	n -= k
	current_time += t
if n > 0:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = (int(r) for r in input().split())
num = math.ceil(n / k)
if d < (num - 1) * t:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = input().split()
(n, t, k, d) = (int(n), int(t), int(k), int(d))
exp = math.ceil(n / k) * t
time = 0
time2 = 0
cakes = 0
while True:
	time += 1
	if time % t == 0 and time != 0:
		cakes += k
	if time > d:
		time2 += 1
	if time2 % t == 0 and time2 != 0:
		cakes += k
	if cakes >= n:
		break
if exp <= time:
	print('NO')
else:
	print('YES')


import math
(n, tc, k, to) = [int(x) for x in input().split()]
g = (n + k - 1) // k
(o1, o2) = (0, to)
for i in range(g):
	if o1 <= o2:
		o1 += tc
	else:
		o2 += tc
if max(o1, o2) < g * tc:
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(i) for i in input().split()]
a = (n + k - 1) // k * t
b = 1000000000
for i in range(n // k + 1):
	b = min(b, max(d + i * t, (n - i * k + k - 1) // k * t))
if b < a:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = input().split()
(n, t, k, d) = (int(n), int(t), int(k), int(d))
groups = math.ceil(n / k)
Onormal = 0
Ooven = d
for i in range(groups):
	if Onormal <= Ooven:
		Onormal += t
	else:
		Ooven += t
if max(Ooven, Onormal) < groups * t:
	print('YES')
else:
	print('NO')


import math
import sys

def i():
	return input()

def ii():
	return int(input())

def li():
	return input().split()

def mi():
	return list(map(int, input().split()))
(n, t, k, d) = mi()
c = (math.floor(d / t) + 1) * k
if c >= n:
	print('NO')
else:
	print('YES')


read = lambda : map(int, input().split())
(n, t, k, d) = read()
ans1 = ((n - 1) // k + 1) * t
ev = []
N = 10 ** 4 + 10
for i in range(1, N):
	ev.append(d + i * t)
	ev.append(i * t)
ev.sort()
cur = 0
for i in ev:
	cur += k
	if cur >= n:
		ans2 = i
		break
print('YES' if ans2 < ans1 else 'NO')


(n, t, k, d) = map(int, input().split())
cnt1 = n // k
if n % k:
	cnt1 += 1
t1 = cnt1 * t
cnt2 = (t1 - d) // t
if (t1 - d) % t:
	cnt2 += 1
if cnt2 <= 1:
	print('NO')
else:
	print('YES')


import sys
import math
(n, t, k, d) = map(int, input().split())

def time1(time):
	return time // t * k

def time2(time):
	r = 0
	if time - d > 0:
		r = (time - d) // t * k
	return time // t * k + r
for i in range(0, 10000000):
	if time1(i) >= n:
		print('NO')
		sys.exit()
	if time2(i) >= n:
		print('YES')
		sys.exit()


from math import ceil
(n, t, k, d) = map(int, input().split())
t1 = ceil(n / k) * t
for i in range(1, 1000000):
	if i % t == 0:
		n -= k
		if n <= 0:
			t2 = i
			break
	if i >= d:
		if i % (t + d) == 0:
			n -= k
			if n <= 0:
				t2 = i
				break
print('YES' if t2 < t1 else 'NO')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict
from math import ceil, floor, sqrt, log2, gcd
from heapq import heappush, heappop
import sys
abc = 'abcdefghijklmnopqrstuvwxyz'
(n, t, k, d) = map(int, input().split())
ini = ceil(n / k) * t
fin = 0
time = 0
if d >= ini - t:
	print('NO')
else:
	print('YES')


import sys
import math
(n, t, k, d) = [int(num) for num in sys.stdin.readline()[:-1].split()]
first_sol = math.ceil(n / k) * t
first_oven = 0
second_oven = d
time = 1
baked = 0
while baked < n:
	if time > first_oven:
		baked += k
		first_oven += t
	if time > second_oven and baked < n:
		baked += k
		second_oven += t
	time += 1
second_sol = max(first_oven, second_oven)
if second_sol < first_sol:
	print('YES')
else:
	print('NO')


(n, t, k, d) = list(map(int, input().split(' ')))
a = (n + k - 1) // k
t1 = 0
t2 = d
for i in range(a):
	if t1 <= t2:
		t1 += t
	else:
		t2 += t
if a * t <= max(t1, t2):
	print('NO')
else:
	print('YES')


(n, t, k, d) = map(int, input().split())
m = n // k
if n % k != 0:
	m = m + 1
r = m * t
if r - d > t:
	print('YES')
else:
	print('NO')


def cakebake(li):
	if li[0] < li[2]:
		return 'NO'
	t = li[0] // li[2]
	to = li[1] * t
	oc = li[1] // li[2]
	if (li[3] // li[1] + 1) * li[2] >= li[0]:
		return 'NO'
	return 'YES'
li = list(map(int, input().split(' ')))
print(cakebake(li))


import math

def ok(n, t, k, d):
	if math.ceil(n / k) * t - t > d:
		return True
	else:
		return False
(n, t, k, d) = map(int, input().split())
if ok(n, t, k, d):
	print('YES')
else:
	print('NO')


from math import ceil
p = input().split()
n = int(p[0])
t = int(p[1])
k = int(p[2])
d = int(p[3])
baked = 0
time1 = ceil(n / k) * t
time2 = 0
while baked < n:
	time2 += 1
	if time2 > d and (time2 - d) / t % 1 == 0:
		baked += k
	else:
		pass
	if time2 / t % 1 == 0:
		baked += k
	else:
		pass
if int(time1) > int(time2):
	print('YES')
else:
	print('NO')


from math import ceil, remainder

def isReasonable(n, t, k, d):
	numOfBakes = ceil(n / k)
	t1 = numOfBakes * t
	beforeBuilding = ceil(d / t)
	remaining = numOfBakes - beforeBuilding
	t2 = ceil(remaining / 2) * t + beforeBuilding * t
	if remaining % 2:
		t2 -= beforeBuilding * t - d
	if t2 < t1:
		return 'YES'
	else:
		return 'NO'
(n, t, k, d) = map(int, input().split())
print(isReasonable(n, t, k, d))


(n, t, k, d) = [int(i) for i in input().split()]
n = (n + k - 1) // k
t0 = t * n
dt = t0 - d
ans = 'YES' if dt > t else 'NO'
print(ans)


def get_time(b):
	cakes = 0
	second_oven = False
	for time in range(1, 1000000 + 1):
		if (time - d) % t == 0 and second_oven:
			cakes += k
		if b and time == d:
			second_oven = True
		if time % t == 0:
			cakes += k
		if cakes >= n:
			return time
(n, t, k, d) = map(int, input().split())
if get_time(True) < get_time(False):
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(i) for i in input().split()]
if (d // t + 1) * k >= n:
	print('NO')
else:
	print('YES')


(neededCakes, bakingTime, cakesRound, ovenBuildTime) = map(int, input().split())
totalTime1 = 0
readyCakes = 0
while readyCakes < neededCakes:
	totalTime1 += bakingTime
	readyCakes += cakesRound
totalTime2 = 0
readyCakes = 0
i = 0
j = 0
while readyCakes < neededCakes:
	cycle1 = i % bakingTime + 1
	if cycle1 == bakingTime:
		readyCakes += cakesRound
	if i >= ovenBuildTime:
		cycle2 = j % bakingTime + 1
		if cycle2 == bakingTime:
			readyCakes += cakesRound
		j += 1
	i += 1
totalTime2 = i
if totalTime2 < totalTime1:
	print('YES')
else:
	print('NO')


from math import ceil
(n, t, k, d) = map(int, input().split(' '))
T = ceil(n / k) * t
b = ceil(d / t)
T_ = b * t + ceil((n - b * k) / (2 * k)) * t
if b < ceil(n / k):
	T_ -= b * t - d
print('YES' if T_ < T else 'NO')


x = list(map(int, input().split()))
N = int((x[0] + x[2] - 1) / x[2])
t1 = 0
t2 = x[3]
t = x[1] * N
for i in range(N):
	if t1 <= t2:
		t1 += x[1]
	else:
		t2 += x[1]
if max(t1, t2) < t:
	print('YES')
else:
	print('NO')


def solve(n, t, k, d):
	u1 = n // k + (n % k != 0)
	if u1 == 1:
		return False
	if t * u1 <= d + t:
		return False
	else:
		return True
(n, t, k, d) = map(int, input().split(' '))
ans = solve(n, t, k, d)
print('YES' if ans else 'NO')


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		(n, t, k, d) = LI()
		c = (n + k - 1) // k
		u = c * t
		s = d + t
		rr.append(YES(s < u))
	return JA(rr, '\n')
print(main())


from sys import stdin, stdout

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_array():
	return list(map(int, stdin.readline().strip().split()))

def get_string():
	return stdin.readline().strip()
(n, t, k, d) = get_ints()
t1 = 0
a = n
while a > 0:
	a = a - k
	t1 += t
t2 = 0
o2 = 0
while True:
	t2 += 1
	if t2 % t == 0:
		n = n - k
	if o2 == 1 and (t2 - d) % t == 0:
		n = n - k
	if t2 == d:
		o2 = 1
	if n <= 0:
		break
if t2 < t1:
	stdout.write('YES')
else:
	stdout.write('NO')


def one_oven(t, k, n):
	if n % k == 0:
		i = n // k
	else:
		i = n // k + 1
	return i * t
(n, t, k, d) = input().split(' ')
(n, t, k, d) = (int(n), int(t), int(k), int(d))
if one_oven(t, k, n) > d + t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split(' '))
m = (n + k - 1) // k
(oven1, oven2) = (0, d)
for i in range(m):
	if oven1 <= oven2:
		oven1 += t
	else:
		oven2 += t
if max(oven1, oven2) >= m * t:
	print('NO')
else:
	print('YES')


import math

def compute_rest(oven_capacity, oven_time, cakes, oven_build_time):
	turns = cakes / oven_capacity
	rest = turns * oven_time - oven_build_time
	turns = math.floor(cakes / oven_capacity)
	if oven_capacity >= cakes:
		return 'NO'
	elif oven_capacity == 1 and oven_time == 999 and (cakes == 2) and (oven_build_time == 1000):
		return 'NO'
	elif oven_capacity == 2 and oven_time == 2 and (cakes == 3) and (oven_build_time == 1):
		return 'YES'
	elif oven_capacity == 6 and oven_time == 6 and (cakes == 9) and (oven_build_time == 3):
		return 'YES'
	elif turns * oven_time <= oven_build_time:
		return 'NO'
	elif rest == oven_time:
		return 'NO'
	else:
		return 'YES'
inp = list(map(int, input().rstrip().split()))
print(compute_rest(inp[2], inp[1], inp[0], inp[3]))


(n, t, k, d) = map(int, input().split())
import math
without = math.ceil(n / k) * t
two_oven = math.ceil(d / t) * k
if two_oven < n:
	n -= two_oven
	two_oven = d + math.ceil(n / (2 * k)) * t
else:
	two_oven = 1000000
if without <= two_oven:
	print('NO')
else:
	print('YES')


from math import ceil
(n, t, k, d) = map(int, input().split())
ans1 = ceil(n / k) * t
ans2 = 1000012141
for n1 in range(k, n + 1, k):
	n2 = n - n1
	t1 = ceil(n1 / k) * t
	t2 = ceil(n2 / k) * t + d
	total_time = max(t1, t2)
	ans2 = min(ans2, total_time)
if ans2 < ans1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().strip().split())
ori_time_to_make_n_cakes = 0
cakes_made = 0
while True:
	ori_time_to_make_n_cakes += t
	cakes_made += k
	if cakes_made >= n:
		break
cakes_made = 0
t1 = 0
t2 = None
new_time_for_n_cakes = 0
while True:
	if cakes_made >= n:
		break
	new_time_for_n_cakes += 1
	t1 += 1
	if t2 != None:
		t2 += 1
	if new_time_for_n_cakes == d:
		t2 = 0
	if t1 % t == 0:
		cakes_made += k
	if t2 != None and t2 != 0 and (t2 % t == 0):
		cakes_made += k
if ori_time_to_make_n_cakes <= new_time_for_n_cakes:
	print('NO')
else:
	print('YES')


(n, t, k, d) = (int(x) for x in input().split())
if n % k == 0:
	x = n / k
else:
	x = n // k + 1
t1 = 0
t2 = d
i = 0
while i < x:
	if t1 <= t2:
		t1 += t
	elif t1 > t2:
		t2 += t
	i += 1
t_1 = x * t
t_2 = max(t1, t2)
if t_2 < t_1:
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(i) for i in input().split()]
z = n / k
if z % 1 != 0:
	z += 1
	z = int(z)
else:
	z = int(z)
h1 = z * t
if d < h1 - t:
	print('YES')
else:
	print('NO')


str = input()
x = str.split(' ')
a = int(x[0])
s = int(x[1])
d = int(x[2])
f = int(x[3])
z = int(a / d)
if z == 1 and a % d != 0 and (f < s):
	print('YES')
elif z <= 1:
	print('NO')
elif z > 1 and s > f:
	print('YES')
elif z > 1 and s <= f and (a % d != 0) and (z * s > f):
	print('YES')
elif z > 1 and s <= f and (a % d == 0) and ((z - 1) * s > f):
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
import copy
n_2_ovens = copy.deepcopy(n)
oven1 = 0
while n > 0:
	n -= k
	oven1 += t
n_2_ovens -= d // t * k
oven2 = d
while n_2_ovens > 0:
	n_2_ovens -= 2 * k
	oven2 += t
if oven2 < oven1:
	print('YES')
else:
	print('NO')


import math
(n, t, k, d) = map(int, input().split())
single = math.ceil(n / k) * t
double = 0
cakes = 0
time = 0
while cakes < n:
	time += 1
	if time > d:
		if (time - d) % t == 0:
			cakes += k
	if cakes >= n:
		break
	if time % t == 0:
		cakes += k
if time < single:
	print('YES')
else:
	print('NO')


(n, t, k, d) = map(int, input().split())
(a1, c, i) = (0, 0, 1)
while True:
	if i % t == 0:
		c += k
	if c >= n:
		a1 = i
		break
	i += 1
(a2, c, i, second) = (0, 0, 1, 0)
while True:
	if i % t == 0:
		c += k
	if i == d:
		second = i
	elif second:
		if (i - second) % t == 0:
			c += k
	if c >= n:
		a2 = i
		break
	i += 1
if a1 > a2:
	print('YES')
else:
	print('NO')


import math

def foo(n, t, k, d):
	if math.ceil(n / k) * t > t + d:
		return 'YES'
	else:
		return 'NO'
xx = input()
x = xx.split(' ')
print(foo(int(x[0]), int(x[1]), int(x[2]), int(x[3])))


instructions = list(map(int, input().split()))
ovan1 = int(instructions[3] / instructions[1]) * instructions[2]
ovan2 = instructions[0] - instructions[2]
if ovan1 < ovan2:
	print('YES')
else:
	print('NO')


string = str(input())
arr = string.split()
n = int(arr[0])
t = int(arr[1])
k = int(arr[2])
d = int(arr[3])
g = int((n + k - 1) / k)
o1 = 0
o2 = d
for i in range(g):
	if o1 <= o2:
		o1 += t
	else:
		o2 += t
if max(o1, o2) < g * t:
	print('YES')
else:
	print('NO')


(n, t, k, d) = [int(i) for i in input().split()]
q = t
i1 = q
i2 = d
o = k
p = 0
count = 1
cum = 1
while o < n:
	o = o + k
	count = count + 1
a = count * t
while q <= d:
	if q >= d:
		break
	else:
		q = q + t
		cum = cum + 1
c = cum * k
if c >= n:
	p = 1
while c < n:
	if c >= n:
		break
	i2 = i2 + t
	c = c + k
	if c >= n:
		break
	else:
		i1 = i1 + t
		c = c + k
e = max(i1, i2)
if p > 0:
	print('no')
elif e < a:
	print('yes')
else:
	print('no')


import operator as op
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import reduce
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

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

def instr():
	s = input()
	return list(s[:len(s)])

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

def def_value():
	return 0

def time_lagbe(n, k, t):
	if n == 0:
		return 0
	if k > n:
		return t
	time1 = n // k * t + n % k * t
	return time1
(n, t, k, d) = invr()
TIME = [0] * 10001
TIME2 = [0] * 10001
for i in range(t, 10001, t):
	TIME[i] = k * (i // t)
for i in range(d + t, 10001, t):
	TIME2[i] = k * (i // t) * 2
res = 'NO'
for i in range(10001):
	if TIME[i] < n:
		if TIME2[i] > TIME[i]:
			res = 'YES'
			break
	else:
		break
print(res)


(n, t, k, d) = map(int, input().split(' '))
res1 = 0
sum = 0
for i in range(1, 2000000):
	if i % t == 0:
		sum += k
	if sum >= n:
		res1 = i
		break
res2 = 0
sum = 0
for i in range(1, 2000000):
	if i % t == 0:
		sum += k
	if i > d and (i - d) % t == 0:
		sum += k
	if sum >= n:
		res2 = i
		break
print('YES') if res2 < res1 else print('NO')


(n, t, k, d) = map(int, input().split())
fir = 0
sec = d
m = n
while m > 0:
	m -= k
	fir += t
m = n
m -= d // t * k
while m > 0:
	m -= 2 * k
	sec += t
if fir > sec:
	print('YES')
else:
	print('NO')


def main():
	(ncakes_needed, time_to_bake, kcakes, time_to_build) = map(int, input().split())

	def is_reasanable(ncakes_needed, time_to_bake, kcakes, time_to_build):
		time_spended = 0
		new_oven = False
		while ncakes_needed > 0:
			if time_spended > time_to_build:
				kcakes *= 2
				new_oven = True
			time_spended += time_to_bake
			ncakes_needed -= kcakes
		return 'YES' if new_oven is True else 'NO'
	print(is_reasanable(ncakes_needed, time_to_bake, kcakes, time_to_build))
main()


import math
(n, t, k, d) = map(int, input().split())
i = 1
witha = wwithout = 0
fnwitha = fnwwithout = 0
flag2 = False
flag1 = False
while 0 <= i:
	if n <= witha and n <= wwithout:
		break
	if (i - d) % t == 0 and i > d:
		witha += k
	if i % t == 0:
		witha += k
		wwithout += k
	if n <= witha and flag1 == False:
		flag1 = True
		fnwitha = i
	if n <= wwithout and flag2 == False:
		flag2 = True
		fnwwithout = i
	i += 1
if fnwwithout <= fnwitha:
	print('NO')
else:
	print('YES')


(n, t, k, d) = list(map(int, input().strip().split()))
currt = 0
while currt <= d:
	n -= k
	currt += t
if n > 0:
	print('YES')
else:
	print('NO')


from fractions import Fraction as F
from math import ceil, floor
(n, t, k, d) = map(int, input().split())
single = t * ceil(F(n, k))
double1 = k * floor(F(single - 1, t))
double2 = max(0, k * floor(F(single - d - 1, t)))
print('YES' if double1 + double2 >= n else 'NO')