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

#print(t2)

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'

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"

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

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

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

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'

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

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

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, raw_input().split())
p = (d + t) / t
print "YES" if k * p < n else "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().split())

if int((n-1)/k)*t > d:
    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] = 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"

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'

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

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

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

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

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 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())
tot = math.ceil(n/float(k))*t
rr = (d+t<tot)
if rr:
    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 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'

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"

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

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

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'

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

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

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"

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

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

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"

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

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

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"

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

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

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

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

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

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

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

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

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

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

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

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

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

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= [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())
#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 = 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")

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

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

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

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

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