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.

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.

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

NoteIn 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.

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

n,t,k,d=map(int,input().split())
n=int(n)
t=int(t)
k=int(k)
d=int(d)
cakes=0
t1=0#time if we use one oven
while cakes<n:
    t1=t1+1
    if t1%t==0:
        cakes=cakes+k

t2=0#time if we use new ovens
cakes=0
t3=0
while cakes<n:
    t2=t2+1
    if t2%t==0:
        cakes=cakes+k
    if t2>d: #new oven has been built and new clock starts for new oven
        t3+=1
    if t3!=0 and t3%t==0:#it counts cakes for second oven after it is built
        cakes+=k
if t2<t1:
    print("YES")
else:
    print("NO")

n,t,k,d=map(int,input().split())
n2=((d+t)//t)*k # n of cake in time d+t
if n2<n:
    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, 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())
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")

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')

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, 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")

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")

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 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

    # time needed for one oven
    t1 = ceil(n / k) * t

    # if t1 <= d:
    #     return "NO"

    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"

if __name__ == '__main__':
    print(main())

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:
            # mulc = mul
            break
    # print(t_muls)
    # print(mul, f"{t * math.ceil(n / k)=}", n, k, t)
    # print(f"{mul=}")
    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
    # print(f"{c1=} {c2=}")
    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"
    # if c2 < t * math.ceil(n / k):
    #     return "YES"
    return "NO"

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

if __name__ == "__main__":
    main()

#####--------------Template Begin-------------------####
import math
import sys
#input = sys.stdin.readline
def i(): #Regular input
	return input()
def ii(): #integer input
	return int(input())
def li(): #list input
	return input().split()
def mi(): #map input
	return list(map(int, input().split()))
#####---------------Template Ends-------------------######
n,t,k,d=mi()
c=(math.floor(d/t)+1)*k
if c>=n:
	print("NO")
else:
	print("YES")

import math
n,t,k,d=map(int,input().split())
a = math.ceil(d/t)
n=n-(a*k)
if n>0:
    if d%t!=0:
        print("YES")
    else:
        if n>k:
            print("YES")
        else:
            print("NO")
else:
    print("NO")

import math
n,t,k,d=map(int,input().split())
g=(n+k-1)//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 = 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,raw_input().split())
r = n/k
if n%k != 0: r+=1
# print r,t,(r-1)*t,k
if d < (r-1)*t: print "YES"
else: print "NO"

[n,t,k,d] = map(int, raw_input().strip().split())

without_new = 0
with_new = d

if n%k == 0:
	without_new = t * (n//k)
else:
	without_new = t * (n//k) + t

remain = n - (((d//t)+1)*k)

flag = True
if remain <= 0:
	flag = False

if remain%k == 0:
	with_new += t
	remain = remain - k
	if remain > 0:
		with_new += t * (remain//(k*2))

else:
	with_new += t
	remain = remain - k
	if remain > 0:
		with_new += t * (remain//(k*2)) + t

if with_new < without_new and flag:
	print "YES"
else:
	print "NO"

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

e = 0
t1 = t
while e < n:
    t1 += t
    e += k

a = t1 -t

t1 = t
t2 = t+d
b = 0
e = 0
while e < n:
    if t1 < t2:
        b = t1
        t1 += t
    else:
        b = t2
        t2 += t
    e += k

if b < a:
    print "YES"
else:
    print "NO"

import fileinput
firstLine=True
for line in fileinput.input():
	splitLine=line.strip().split(" ")
	if firstLine:
		(n,t,k,d)= (int(splitLine[0]),int(splitLine[1]),int(splitLine[2]),int(splitLine[3]))
		firstLine=False
		if ((d+t)/t)*k<(n):
			print "YES"
		else:
			print "NO"
		exit()
	else: exit()

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
# baked = 0
for i in range(baking_time):
    if o1 == 0 :
        n -= k
        o1 = t

    if o2 == 0 :
        n-=k
        o2 = t

    if n<1:
        # print(i,n)
        build_oven = "YES"
        # break
    o1 -=1
    o2 -=1
    # print(i ,o1,o2,n)

print(build_oven)

n, t, k, d = map( int, input().split() )
clk = 0
s = 0
while s < n:
  s += k
  clk += t
clk2 = 0
lb, ub = 0, int( 1e10 )
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())
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")

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');

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')

from math import ceil
n, t, k, d = map(int, raw_input().split())

req = ceil(float(n)/float(k)) * t
#print req

pd2 = d / t * k
time = d

#print pd2

while pd2 < n :
    time += 1
    if (time - d) % t == 0:
        pd2 += k
    if time % t == 0:
        pd2 += k
    #print time, pd2

#print time -1
if (time >= req):
    print 'NO'
else :
    print 'YES'

import math
n,t,k,d=map(int,input().split())
fot=math.ceil(n/k)*t
if t>d:
    if k<n:
        print("YES")
    else:
        print("NO")
else:
    if k<n:
        if n-k*(math.floor(d/t))>k:
            print("YES")
        else:
            print("NO")
    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")

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')

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')

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
# For getting input from input.txt file
#sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
#sys.stdout = open('output.txt', 'w')

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)

from math import ceil
n,t,k,d=map(int,raw_input().split())
t1=int(ceil(n*1.0/k)*t)
if d<t1-t:
	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")

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")

n, t, k, d = map(int, input().split())
#5 5 4 4
mult =  n//k
if (n%k >= 1):
	mult += 1

no = mult * t

yesCount = n
yes = d

yesCount -= ((d//t)*k)  # 10

while(yesCount > 0):
	yesCount -= (k*2)
	yes += t
if(k >= n):
	print("NO")
else:
	if(no <= yes):
		print("NO")
	else:
		print("YES")

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

a = (n + k - 1) / k * t

b = d + t

print 'YES' if b < a else '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")

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
n,t,k,d = map(int,raw_input().split())
p1 = math.ceil(n*1.0/k)*t
a = d/t
b = d%t
c = int(math.ceil(n*1./k)-a)
#print a,b,c
if c%2==0:
	if a==0:
		p2 = d+c/2*t
	else:
		p2 = (a+c/2)*t
else:
	if a==0:
		p2 = d+c/2*t+t
	else:
		p2 = (a+c/2+1)*t
#print p1,p2
print 'YES' if p1 > p2 else 'NO'

from sys import maxsize, stdout, stdin, stderr
# mod = int(1e9 + 7)
import re  # can use multiple splits
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('\033[3{}m'.format(c), *args, '\033[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: #TIME TO COOK THE FIRST BATCH OF CAKES TILL THE PREPARATION OF THE SECOND OVEN
    n-=k
    c+=t
#IF THERE ARE STILL CARROTS LEFT THEN WE CAN USE THE SECOND OVEN TO BAKE MORE CARROTS
if n >0:print("YES")
else:print("NO")

n, t, k, d = map(int, raw_input().split())
# k * s >= n
# s >= n / k
s = -1
if n % k == 0:
    s = n / k
else:
    s = n / k + 1
T1 = s * t
for i in range(0, T1):
    T2 = i
    total = 0
    total += T2 / t * k
    total += max(0, T2 - d) / t * k
    if total >= n:
        print 'YES'
        exit(0)
print 'NO'

import math
n,t,k,d = map(int,raw_input().split())
tot = math.ceil(n/float(k))*t
rr = (d+t<tot)
if rr:
    print "YES"
else:
    print "NO"

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

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

#number of batch for first oven
batch=0
if k<n:
    batch =(n/k)

    if batch%1!=0:
        batch = int(batch)+1
else:
    batch=1

if(batch * t >(t+d)):
    print("YES")
else:
    print("NO")

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) :
    # print(i)
    n-= k
if n > 0 :
    print("YES")
else :
    print("No")
# print(n)

import math

n, t, k, d = map(int, raw_input().split())
blocks = int(math.ceil((n * 1.0) / k))
without = blocks * t
a, b = 0, d
while blocks > 0:
    if a < b:
        a += t
    else:
        b += t
    blocks -= 1
withoven = max(a, b)

if withoven < without:
    print 'YES'
else:
    print 'NO'

import math

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

ans = 'NO'
if 1.*n/k > 1:
    rounds = math.ceil(1. * n / k)
    t1 = rounds*t
    rounds_during_build = d/t
    rounds_after_build = rounds - rounds_during_build
    t2 = max((rounds_during_build + (rounds_after_build+1)/2)*t, rounds_after_build/2*t+d)
    # print t1, t2
    if t2 < t1:
        ans = 'YES'
print ans

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

if int((n-1)/k)*t > d:
    print('YES')
else:
    print('NO')

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")

n, t, k, d = map(int, raw_input().split())
x = 0
for i in range(n, 0, -k): x += t
c = (x - 1) / t * k
if (x - 1 >= d): c += (x - 1 - d) / t * k
print 'YES' if (c >= n) else '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])

import math

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

x=math.ceil(n/float(k))*t

if(x>t+d):
    print "YES"
else:
    print "NO"

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())

n,t,k,d=map(int,raw_input().split())
y=n/k
if n%k>0:
    y+=1
x=y*t
z=0
for i in range(1,1000001):
    if i%t==0:
        n-=k
    if i>d and (i-d)%t==0:
        n-=k
    if n<=0:
        z=i
        break
# print x,z
if z<x:
    print "YES"
else:
    print "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, raw_input().split())
p = (d + t) / t
print "YES" if k * p < n else "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
##print('up', up)
##print('down', down)
##print('mid', mid)

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

##print('s1', s1)
##print('s2', s2)
if s2<s1:
    print('YES')
else:
    print('NO')

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')

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

def main():
    n, t, k, d = (int(i) for i in input().split())
    carrotCakes(n, t, k, d)

if __name__ == '__main__':
    main()

import math
n,t,k,d=map(int,input().split())
g=(n+k-1)//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=(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");

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")

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))
# t_2 = d + t*(n-d*k/t)/k/2
    if d % t == 0:
        # t_2 = d + t*(n-k)/k/2
        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 = math.ceil(d/t)
        x = d//t
        # t_2 = x*t
        t_2 = (x+1)*t
        # m = x*k
        m = (x+1)*k
        while m < n:
            # t_2 += d-(x-1)*t
            t_2 += d-x*t
            m += k
            if m < n:
                # t_2 += x*t-d
                t_2 += (x+1)*t-d
                m += k
    # print(t_1)
    # print(t_2)
    if t_1 > t_2:
        print('YES')
    else:
        print('NO')

PROBLEM = "A"
FILE = "%s" %(PROBLEM)
INF = 999999999999999999L
try:
    inFile = open(FILE+".txt")
except:
    inFile = None

def read():
    if inFile:
        return inFile.readline().strip()
    else:
        return raw_input().strip()

def read_ints():
    return map(int,read().split())

n,t,k,d = read_ints()

one_oven = (n+k-1)/k * t

two_ovens = d
n -= (d/t) * k
if n > 0:
    k *= 2
    two_ovens += (n+k-1)/k * t

#print one_oven
#print two_ovens

if one_oven <= two_ovens:
    print "NO"
else:
    print "YES"

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

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 needed(n,t,k,q):
    isNeeded = False
    if(n<k):
        return isNeeded
    if n%k==0:
        noOfBakesNeeded = n/k
    else:
        noOfBakesNeeded = (n/k)+1
    # print noOfBakesNeeded
    bakesLeft = noOfBakesNeeded
    # if (q%t==0):
    bakesLeft = noOfBakesNeeded - (q/t)
    # print bakesLeft
    if bakesLeft==1:
        return isNeeded
    if noOfBakesNeeded*t > (q+(bakesLeft/2)*t):
        isNeeded = True
    # else:
    #     bakesLeft = noOfBakesNeeded - q/t

    # if noOfBakesNeeded*t > (q+(noOfBakesNeeded/2)*t):
    #     isNeeded = True
    return isNeeded

n,t,k,q = map(int, raw_input().split(" "))
if needed(n,t,k,q):
    print "YES"
else:
    print "NO"
# print "YES" if needed(n,t,k,q)==True else "NO"

n,t,k,d = map(int, input().split())
# print(n,t,k,d)
# z= (d/t)+1
# m=d*k/t
# f= ((n/k)-m)*t/(2*k)
if (((d//t)+1)*k)>=n:
    print("No")
else:
    print("YES")

# Carrot Cakes

"""
  Thinking time: 6
    Coding time: 2
 Debugging time: 4
 -----------------------------
     Total time: 12 minutes
"""

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")

l=map(int,raw_input().split())
n=l[0]
t=l[1]
k=l[2]
d=l[3]
if n%k >0:
    time=t+t*(n/k)
else:
    time=t*(n/k)
time-=t
if d<time:
    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')

def  sol():
    i = list(map(int, raw_input().split()))
    n,t,k,d = i[0],i[1],i[2],i[3]

    mint = n/k
    if n%k!=0: mint += 1

    if mint*t> d+t:
        print 'YES'
    else:
        print 'NO'

sol()

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

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

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")
else:
    if (n // k + 1) * t > finish:
        print("YES")
    else:
        print("NO")

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

# two oven
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')

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")

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')

n, t, k, d = map(int, input().split())
#5 5 4 4
mult =  n//k
if (n%k >= 1):
	mult += 1

no = mult * t

yesCount = n
yes = d

yesCount -= ((d//t)*k)  # 10

while(yesCount > 0):
	yesCount -= (k*2)
	yes += t
if(k >= n):
	print("NO")
else:
	if(no <= yes):
		print("NO")
	else:
		print("YES")

[N, T, K, D] = map(int, raw_input().split())

Am = 1
Bm = 1

Count = 0
while(True):
    if Am % T == 0:
        Count += K
    if Count >= N:
        break
    Am += 1

Count = 0
while(True):
    if Bm % T == 0:
        Count += K
    if Bm > D:
        if (Bm - D) % T == 0:
            Count += K
    if Count >= N:
        break
    Bm += 1

if Bm >= Am:
    print "NO"
else:
    print "YES"

import math
n,t,k,d=map(int,input().split())
a = math.ceil(d/t)
n=n-(a*k)
if n>0:
    if d%t!=0:
        print("YES")
    else:
        if n>k:
            print("YES")
        else:
            print("NO")
else:
    print("NO")

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

q1, q2 = 0, d
g = (n + k -1) /k
for i in xrange(g):
    if q1 <= q2:
        q1 += t
    else:
        q2 += t
if max(q1, q2) < g * t:
    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');

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())
t1, t2 = 0, d

while n > 0:
    if t1 <= t2:
        t1 += t
        n -= k
    else:
        t2 += t
        n -= k

if t2 == d:
    print("NO")
else:
    print("YES")

n,t,k,d=map(int,input().split())
n2=((d+t)//t)*k # n of cake in time d+t
if n2<n:
    print("YES")
else:
    print("NO")

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

n, t, d, k = map(int, input().split())
if (d / (t + 1) * k) < n:
    print("YES")
else:
    print("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:
            # mulc = mul
            break
    # print(t_muls)
    # print(mul, f"{t * math.ceil(n / k)=}", n, k, t)
    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):
        return "YES"
    if c2 < t * math.ceil(n / k):
        return "YES"
    return "NO"

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

if __name__ == "__main__":
    main()

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

a,b,c,d = map(int,input().split())
t1 = 0
t2 = 0
if a % c == 0:
	k = a//c
else:
	k = a//c+1
t1 = b * k
t2 += d
t2 += t1 // 2
if t1 <= t2:
	print("NO")
else:
	print("YES")

"""609C"""
def main():
	n,t,k,d = map(int,input().split())
	time = 0
	cakes = 0
	while time<d:
		time += t
		cakes += k
	if cakes>=n:
		print("NO")
	else:
		print("YES")

main()

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

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

import math
def carrotCakes(n, t, k, d):
    if k < n:
        if math.ceil(n/k) * t > d + t: print('YES')
        else: print('NO')
    else:
        if t > d: print ('YES')
        else: print('NO')

def main():
    n, t, k, d = (int(i) for i in input().split())
    carrotCakes(n, t, k, d)

if __name__ == '__main__':
    main()

ns = [int(s) for s in input().split(' ')]
n = ns[0]
t = ns[1]
k = ns[2]
d = ns[3]
db = 1

together = d % t
cakes_during_building = (d * k) // t
after_building = n - cakes_during_building
if db == 1:
    #print("time for one oven: ",one_oven)
    #print("time for two oven: ",two_oven)
    print("left cakes to make after d: ",after_building)
    print("cakes made druing d: ", cakes_during_building)
    #print("bakes per min: ",baked_per_minute)
    print("total cakes: ", n)
    print("d :", d)
    print("cakes per min :", k , t)
    print(together)
if after_building <= 0 or after_building <= k :
    print("NO")
else:
    print("YES")

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 t1<=t2:
    print("NO")
else:
    print("YES")

data = input('').split(' ')

n, t, k, d = [int(i) for i in data]

time_one_oven = round(n/k) * t
time_build_oven = d + t

if time_build_oven < time_one_oven:
  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()
cakes2=0
i2=0
for i in range(1,1001):
	if i%t==0:
		cakes2+=k
	if cakes2 >=n :
		i2=i
		break
cakes=0
for i in range(1,1001):
	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())
x1 = (n * t) / k # Time required ta bake using only one oven
c = (k * d) / t # Number of cakes baked while building the oven
n = n - c # remaining cakes

# Calculate the time required to bake the remiaing cakes after building the second oven-it will half time of course- then add the time taken in building the second one
x2 = ((n * t) /k) / 2 + d

print(["NO", "YES"][x2 < x1])

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

if (n // k ) * t > d + t:
    print('YES')
else:
    print('NO')

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 d%t==0):
        print("NO")
    else:
        print("YES")

import math

def calc_feasible(n,t,k,d):
    #calculate time for oven1 alone
    time_single_oven = math.ceil((n/k)) * t

    #calculate time for oven1 and oven2 together
    if d <= t:
        time_oven1 = math.ceil(n/(2*k)) * t
        time_oven2 = time_oven1 + (d-t)
        time_both_oven = time_oven1 + time_oven2
    else:
        #find how many cakes can be baked by the time second oven is ready
        x = math.floor(d/t) * k
        if (n-x) <= 0 or (n-x) < k:
            print "NO"
            return
        time_oven1 = math.ceil((n-x)/(2*k)) * t
        time_oven2 = time_oven1 + (d % t) - t
        time_both_oven = time_oven1 + time_oven2
    if time_single_oven <= time_both_oven:
        print "NO"
        return
    else:
        print "YES"
        return

n, t, k, d = map(int, raw_input().split(' '))
calc_feasible(n, t, k , d)

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

def solution(n,t,k,d):
   #without second oven:
    w = math.floor((n*t)/k)
    m = math.floor(((n-d)*t)/k) + math.floor((d*t)/k)
    if w >= m:
        return 'YES'
    else:
        return 'NO'

print(solution(n,t,k,d))

n,t,k,d=map(int,input().split())
a = (n//k)*t
b = t+d
if k>=n:
    print('NO')
else:
    if a<=b:
        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")

elif(d/t==1):
    if(n-k<=k):
        print("NO")
    elif(n-k>k):
        print("YES")
elif((d/t)>1):
    from math import ceil
    if(ceil(d/t)*k>=n or k>=n-(ceil(d/t)*k)):
        print("NO")
    else:
        print("YES")

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

mult =  n//k
if (n%k > 1):
	mult += 1

no = mult * t

yesCount = 0
yes = d
if(d > t):
	yesCount = k

while(yesCount < t):
	yesCount += (k*2)
	yes += t

if(k >= n):
	print("NO")
else:
	if(no <= yes):
		print("NO")
	else:
		print("YES")

# https://codeforces.com/contest/799/problem/A

noOfCakesToBeMade, minsOvenReqToBakeABatchOfCakes, noOfCakesInABatch, minsReqToBuildAOven = [int(x) for x in input().split(' ')]

timerForOneOven = (noOfCakesToBeMade / noOfCakesInABatch) * minsOvenReqToBakeABatchOfCakes

noOfCakesReady = 0
timer = 0
secondOvenTimer = 0

while noOfCakesReady < noOfCakesToBeMade:
    timer += 1

    if (timer / minsOvenReqToBakeABatchOfCakes).is_integer():
        noOfCakesReady += noOfCakesInABatch

    if timer > minsReqToBuildAOven:
        secondOvenTimer += 1
        if (secondOvenTimer / minsOvenReqToBakeABatchOfCakes).is_integer():
            noOfCakesReady += noOfCakesInABatch

if timer < timerForOneOven:
    print('YES')
else:
    print('NO')

import math
n, time, cakes, build_time = map(int, input().split())
itr = math.ceil(n/cakes)
single = itr*time
build_overlap = 0 if build_time < time and math.ceil(single - build_time)/time > 1 else build_time - time
double = build_overlap + single/2 if itr-1 > 1 or build_time < time else single * 2
print("YES" if double < single else "NO")

n,t,k,d=map(int,raw_input().split())
if n/k==(n*1.0)/k:
  vr=n/k
else:
  vr=n/k+1
if(t>d and n>k):
    print "YES"

elif(t<d and vr>d):
    print "YES"
else:
    print "NO"

import math
n,t,k,d=map(int,input().split())
res=(n+k-1)/k
res*=t
if res>d+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

        if is_ready2:
            double += 2 * k

        if single >= n:
            print('NO')
            return

        if double >= n:
            print('YES')
            return

        time += 1

if __name__ == '__main__':
    main()

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

n,t,k,d=map(int,input().split())
if k > n:
	print("NO")
	exit()
a=0
m=k
while(m < n):
	m+=k
	a+=1
fans=a*t
sans=t+d
if fans < sans:
	print("NO")
else:print("YES")

n,t,k,d = map(int,input().split())
a = -(-n//k)*t
ns = k/t
t1 = 0
nt = 0
nt1 = 0
nt2 = 0
c = False
while nt<n:
	if t1>=d:
		nt2+= ns
		nt1+= ns
	else:
		nt1+=ns
	if nt1>=k:
		nt+=k
		nt1=0
	if nt2>=k:
		nt+=k
		nt2=0
		c = 1
	t1+=1

if a>t1-1:
	if c:
		print("YES")
	else:
		print("NO")

else:
	print("NO")

x = list(map(int, input().rstrip().split()))
if x[0] <= x[2] or x[3] == [1]: print('NO')
elif x[3] < x[1]: print('Yes')
else:
    oldt = (x[0]/x[2]) * x[1]
    newn = (x[3] * x[2]) / x[1]
    newt = (newn/x[2]) * x[1]
    if oldt > newt: print('YES')
    else: print('NO')

ns = [int(s) for s in input().split(' ')]
n = ns[0]
t = ns[1]
k = ns[2]
d = ns[3]
db = 1

during_building = (d / t)
together = d % t
cakes_during_building = during_building * k
after_building = n - cakes_during_building
if db == 1:
    #print("time for one oven: ",one_oven)
    #print("time for two oven: ",two_oven)
    print("left cakes to make after d: ",after_building)
    print("cakes made druing d: ", cakes_during_building)
    #print("bakes per min: ",baked_per_minute)
    print("total cakes: ", n)
    print("d :", d)
    print("cakes per min :", k , t)
    print(together)
if after_building <= 0 or (after_building <= k and together == 0):
    print("NO")
else:
    print("YES")

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

def pies_for_time(time, t, k):
    return (time // t) * k

def pies(count, t, k, d):
    # работает только одна печка
    t1 = (count // k + (0 if count % k == 0 else 1)) * t

    if count < pies_for_time(t1 - 1 - d, t, k) + pies_for_time(t1 - 1, t, k):
        return "YES"
    return "NO"

print(pies(a1, a2, a3, a4))

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
# For getting input from input.txt file
#sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
#sys.stdout = open('output.txt', 'w')

n, t, k, d = invr()

TIME = [0]*1001
TIME2 = [0]*1001

for i in range(t, 1001, t):

    TIME[i] = k*(i//t)

for i in range(d+t, 1001, t):
    TIME2[i] = k * (i//t) * 2
res = "NO"
for i in range(1001):
    if TIME[i] < n:
        if TIME2[i] > TIME[i]:
            res = "YES"
            break
    else:
        break
# print(TIME[:20])
# print(TIME2[:20])
print(res)

import math
n,t,k,d = map(int,raw_input().split())
print 'YES' if math.ceil(n*1.0/k)*t > math.ceil(math.ceil(n*1./k-math.ceil(d*1./t))/2)*t+d else 'NO'

n,t,k,d=map(int,input().split())
if k > n:
	print("NO")
	exit()
a=0
g=k
m=k
while(m < n):
	m+=k
	a+=1
fans=a*t
sans=t+d
b=0
while(k < n):
	k+=g
	b+=1
sans*=b
if fans < sans:
	print("NO")
else:print("YES")

n,t,k,d=map(int,raw_input().split())
if(t>d and n>k):
    print "YES"
elif(t<d and n/k+1>=d):
    print "YES"
else:
    print "NO"

from math import floor
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 = (n*t)/k
if timeBuild > timeNoBuild: print("NO")
else: print("YES")

import math

def main():
    n, t, k, d = map(int, raw_input().split())
    t1 = math.ceil(n/float(k)) * t
    if d > t:
        t2 = d+ math.ceil((n-(d/t)*k)/float(k*2))*t
    else:
        t2 = t + math.ceil((n-k)/float(k*2))*min(t,d)

    print t1,t2
    if t2 < t1:
        print 'YES'
    else:
        print 'NO'

if __name__ == '__main__':
    main()

n,t,k,d = list(map(int,input().split()))
n_new = int(n/k)
oven1 ,oven2 = 0 , d
for i in range(n_new):
    if oven1 < oven2 : oven1 += t
    else: oven2 += t
print("YES" if max(oven1,oven2)<(n_new*t) else "NO")

import sys

n,t,k,d = map(int, sys.stdin.readline().split())
now = 0
one = 0
two = 0
for i in range(1, 100001):
    one = i
    if now >= n:
        break
    if i % t == 0:
        now += k

now = 0
for i in range(1, 100001):
    two = i
    if now >= n:
        break
    if i % t == 0:
        now += k
    if i - d > 0 and (i - d) % t == 0:
        now += k

print('YES' if one > two else 'NO')

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

if d%t == 0 and t%k !=0 and d!=t:
    print("NO")
else:
    if (n+k-1)//k * t - d >= t:
        print("YES")
    else:
        print("NO")

ns = [int(s) for s in input().split(' ')]
n = ns[0]
t = ns[1]
k = ns[2]
d = ns[3]
db = 0

during_building = (d / t)
together = d % t
cakes_during_building = during_building * k
after_building = n - cakes_during_building
if db == 1:
    #print("time for one oven: ",one_oven)
    #print("time for two oven: ",two_oven)
    print("left cakes to make after d: ",after_building)
    print("cakes made druing d: ", cakes_during_building)
    #print("bakes per min: ",baked_per_minute)
    print("total cakes: ", n)
    print("d :", d)
    print("cakes per min :", k , t)
if after_building <= 2 * k and together == 0:
    print("NO")
else:
    print("YES")

n, t, k, d = map(int,input().split())
from math import ceil
n = ceil(n / k)

t1 = n * t
t2 = d + ceil(n/ 2) * t
print(t1)
print(t2)

if t1>t2:
    print("YES")
else:
    print("NO")
#4 2 1 4

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 =  (mid/t)*k + (mid-d)/t*k
       if(h1 >= n): r = mid
       else: l = mid
    return r

n, t, k, d = map(int, input().split())
print(khong(n, t, k, d))
if(co(n, t, k, d) < khong(n, t, k, d)):
   print("YES")
else: print("NO")

import math
def compute_rest(oven_capacity, oven_time, cakes, oven_build_time):
    turns = cakes/oven_capacity
    rest = (turns * oven_time) - oven_build_time
    if oven_capacity >= cakes:
        return 'NO'
    elif (turns == 2) and (oven_time <= oven_build_time):
        return 'NO'
    elif turns*oven_time <= oven_build_time:
        return 'NO'
    elif turns*oven_time > oven_build_time and 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, raw_input().split())

t1 = 0
cakes = 0
while cakes < n:
	t1 += t
	cakes += k

ncakes = 0
t2 = 0
t3 = 0
flag = 0
while ncakes < n:
	t2 += 1
	if t2 == d:
		flag = 1
	if flag:
		t3 += 1
	if t3%t == 0 and t3 != 0:
		ncakes += k
	if t2%t == 0  and t2 != 0:
		ncakes += k

# t3 + d - t2
# t2 = t2 - t + min(t, d)
t2 = max(t3 + d, t2)
# print t2, t1

if t2 < t1:
	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 = 1
while cakes < n:
    if time > d:
        if (time - d) % t == 0:
            cakes += k

    if cakes >= n:
        break

    if time % t == 0:
        cakes += k
    time += 1

if time < single:
    print('YES')
else:
    print('NO')

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")

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

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

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

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

i = 0
baked = 0
while baked < n:
	i += 1
	if i % t == 0:
		baked += k
	if i > d and ((i-d) % t == 0):
		baked += k

if i <= d + t:
	print("NO")
else:
	print("YES")

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

# one oven
one_oven = n * t / k

# two oven
o1 = 0
o2 = d

for x in range(n // k):
    if (o1 <= o2):
        o1 += t
    else:
        o2 += t

if one_oven <= max(o1, o2):
    print('NO')

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

one_oven = n * t / k

two_oven = d + (one_oven / 2)

if one_oven > two_oven:
    print('YES')

else:
    print('NO')

print(one_oven, two_oven)

n,t,k,d=map(int,raw_input().split())
if d+1 > t and (2*k)+1 > n:
    print 'NO'
else:
    print 'YES'

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

print('YES') if( int(a[0]/a[2])-1) * a[1] > a[3] else print('NO')

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

n,t,k,d=map(int,input().split())
if k > n:
	print("NO")
	exit()
a=0
g=k
m=k
while(m < n):
	m+=k
	a+=1
fans=a*t
sans=t+d
b=0
while(k < n):
	k+=g
	b+=1
sans*=b
if fans < sans:
	print("NO")
else:print("YES")

import math
def compute_rest(oven_capacity, oven_time, cakes, oven_build_time):
    turns = math.floor((cakes/oven_capacity))
    if oven_capacity >= cakes:
        return 'NO'
    elif (turns == 2) and (oven_time <= oven_build_time):
        return 'NO'
    elif turns*oven_time <= oven_build_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())

if d < t:
	print("YES")
else:
	oven = d // t
	# print(str(oven)[2])
	if n - k * int(oven) > k:
		print("YES")
	else:
		print("NO")

import sys

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

    # time needed for one oven
    t1 = int(n / k + 0.5) * t

    for b in range(1, n + 1):
        for a in range(b, b + int(d / t + 0.5) + 1):
            if (a + b) * k >= n:
                if max(a * t, d + b * t) < t1:
                    print("YES")
                    return "YES"
                else:
                    print("NO")
                    return "NO"

if __name__ == '__main__':
    main()

reqd,min_to_bake,bake_per_min,oven = map(int, input().split())
h = "NO"
x = reqd // bake_per_min
print(x)
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)

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

def solution(n,t,k,d):
   #without second oven:

    w = math.ceil(n/k * t)
    x = (n-d/t)/k * 0.5*t
   #with second oven:
    m = math.ceil(d + n/k *0.5 *t)

    if w > m:
        return 'YES'
    else:
        return 'NO'

print(solution(n,t,k,d))

x = list(map(int, input().rstrip().split()))
if x[0] <= x[2] or x[3] == [1]: print('NO')
elif x[3] < x[1]: print('Yes')
else:
    oldt = (x[0]/x[2]) * x[1]
    newn = (x[3] * x[2]) / x[1]
    newt = (newn/x[2]) * x[1]
    if oldt > newt: print('YES')
    else: print('NO')

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()

str=input()
x=str.split(" ")
a=int(x[0])
s=int(x[1])
d=int(x[2])
f=int(x[3])
z=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")

import sys

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(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:
        timet = k * ((mul // t) + (mul - d) // t)
        if timet >= n:
            # mulc = mul
            break
    if timet < t * (n // k):
        return "YES"
    return "NO"

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

if __name__ == "__main__":
    main()

# automate the second oven scenario with a for loop
n, t, c, d = input().split()
cakes_needed = int(n)
time = int(t)
cakes_in_progress = int(c)
second_oven = int(d)

single_oven_scenario = time * cakes_needed / cakes_in_progress

counter = 0
cakes = 0
for l in range(0, second_oven, time):
    if l < second_oven:
        cakes += cakes_in_progress
        counter += time
    else:
        counter = counter + ((cakes_needed - cakes) / 2 * time)
if counter < single_oven_scenario:
    print("YES")
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 t1<=t2:
    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
rest =  n -  math.ceil(d/t) * k
if rest > k or d < t:
    print("YES")
else:
    print("NO")

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

if __name__ == '__main__':
    main()

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

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

import math
def carrotCakes(n, t, k, d):
    t1, t2 = 0, d
    for i in range(math.ceil(n / k)):
        if t1 <= t2: t1 += t
        else: t2 += t
    if max(t1, t2) < math.ceil(n / k): print('YES')
    else: print('NO')

def main():
    n, t, k, d = (int(i) for i in input().split())
    carrotCakes(n, t, k, d)

if __name__ == '__main__':
    main()

from math import ceil
n,t,k,d = map(int, input().split())
print("YES" if(ceil(n/k)*t > t) else "NO")
#Aloosh

str=input()
x=str.split(" ")
a=int(x[0])
s=int(x[1])
d=int(x[2])
f=int(x[3])
z=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())
n1 = n
if n < k:
	a = n*(t/k)
else:
	a = t
n1 -= k
while n1 > 0:
	a += t
	n1 -= k
b = d
if d > t:
	n -= (d/t)*k
else:
	n -= k
while n>0:
	b += t
	n -= 2*k
print('YES') if a > b else print('NO')

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_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]))

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):
    if(time % t == 0 and time != 0):
        cakes += k
    if(time >= d):
        time2 += 1
    if(time2 % t == 0 and time2 != 0):
        cakes += k
    time += 1
    if(cakes >= n):
        break
if(exp < time):
    print('NO')
else :
    print('YES')

n,t,k,d=map(int,input().split())
secOven=t+d
firstOven=(n//k)*t
if firstOven>secOven:
	print("YES")
else:
	print("NO")

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

    if before <= after:
        isOK = 0
    else:
        isOK = 0
if isOK ==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')
else:
    if d<t:
        print('YES')
    elif n-(d//t)*k>k:
        print('YES')
    else:
        print('NO')

from sys import maxsize, stdout, stdin, stderr
# mod = int(1e9 + 7)
import re  # can use multiple splits
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('\033[3{}m'.format(c), *args, '\033[0m', file=stderr)
stpr = lambda x  : stdout.write(f'{x}' + '\n')
star = lambda x : print(' '.join(map(str , x)))
n , t , k , d = tup()
time_wo = (n//k )*t
timw_wi = (n//(2*k) )*t + d
if timw_wi <= time_wo:
    print("YES")
else:print("NO")

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

t1 = 0
t2 = d

one = 0
b = 0
while b < n:
    one += t
    b += k

baked = 0

while baked < n:
    if t1 >= d:
        t2 += t
        baked += k

    t1 += t
    baked += k

both = min(t1, t2)

if one <= both:
    print('NO')
else:
    print('YES')

n,t,k,d = list(map(int,input().split()))
from math import ceil
fi = ceil(n/k) * t
if d >= t and fi <= 2*t:
    print("NO")
else:
    print("YES")

x = list(map(int, input().rstrip().split()))

if x[0] <= x[2] or x[3] == x[1]:
    print('NO')
elif x[3] < x[1]:
    print('Yes')
else:
    oldt = (x[0]/x[2]) * x[1]
    newn = (x[3] * x[2]) / x[1]
    newt = (newn/x[2]) * x[1]
    if oldt > newt: print('YES')
    else: print('NO')

import math
n, time, cakes, build_time = map(int, input().split())
itr = math.ceil(n/cakes)
single = itr*time
build_overlap = 0 if build_time < time and math.ceil(single - build_time)/time > 1 else build_time % time
parallel_itr = math.ceil((single-build_time)/time)/2
parallel_time = parallel_itr*time
linear_time = itr-parallel_itr*time
double = build_overlap + parallel_time + linear_time if itr-1 > 1 or build_time < time else single * 2
print("YES" if double < single else "NO")

# automate the second oven scenario with a for loop
import math
n, t, c, d = input().split()
cakes_needed = int(n)
time = int(t)
cakes_in_progress = int(c)
second_oven = int(d)

single_oven_scenario = math.ceil(time * cakes_needed / cakes_in_progress)

counter = 0
time_counter = 0
for l in range(cakes_needed, -1, cakes_in_progress):
    time_counter += time
    l -= cakes_in_progress
    if time_counter >= second_oven:
        l -= cakes_in_progress
    counter += 1
final_time = counter * time
if final_time < single_oven_scenario:
    print("YES")
else:
    print("NO")