Problem:
 Score : 200 points    Problem Statement Takahashi and Aoki will have a battle using their monsters.  The health and strength of Takahashi's monster are A and B , respectively, and those of Aoki's monster are C and D , respectively.  The two monsters will take turns attacking, in the order Takahashi's, Aoki's, Takahashi's, Aoki's, ...
Here, an attack decreases the opponent's health by the value equal to the attacker's strength.
The monsters keep attacking until the health of one monster becomes 0 or below. The person with the monster whose health becomes 0 or below loses, and the other person wins.  If Takahashi will win, print Yes ; if he will lose, print No .      Constraints  1 \leq A,B,C,D \leq 100  All values in input are integers.         Input Input is given from Standard Input in the following format:  A  B  C  D       Output If Takahashi will win, print Yes ; if he will lose, print No .        Sample Input 1 10 9 10 10      Sample Output 1 No  First, Takahashi's monster attacks Aoki's monster, whose health is now 10-9=1 .  Next, Aoki's monster attacks Takahashi's monster, whose health is now 10-10=0 .  Takahashi's monster is the first to have 0 or less health, so Takahashi loses.       Sample Input 2 46 4 40 5      Sample Output 2 Yes

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 6)  
to_index = lambda x: int(x) - 1  
print_list_in_2D = lambda x: print(*x, sep="\n")  


def input_int():
    return int(input())

def map_int_input():
    return map(int, input())

MII = map_int_input

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

def MII_to_index():
    return map(to_index, input())

def MII_split_to_index():
    return map(to_index, input().split())


def list_int_inputs():
    return list(map(int, input()))

LII = list_int_inputs

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


def LII_2D(rows_number):
    return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number):
    return [LII_split() for _ in range(rows_number)]

A, B, C, D = MII_split()

while True:
    C -= B
    if C <= 0:
        print('Yes')
        exit()
    A -= D
    if A <= 0:
        print('No')
        exit()

Solution (Python):



import sys



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

for i in range(100):
    C -= B
    if C <= 0:
        print('Yes')
        sys.exit()
    A -= D
    if A <= 0:
        print('No')
        sys.exit()

Solution (Python):
from math import ceil
a,b,c,d=map(int,input().split())
takahashi=ceil(c/b)
aoki=ceil(a/d)
if takahashi<=aoki:
    print('Yes')
else:
    print('No')

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

Solution (Python):
a, b, c, d = map(int, input().split())

while True:
  c -= b
  if c <= 0:
    print("Yes")
    break
  a -= d
  if a <= 0:
    print("No")
    break

Solution (Python):
a,b,c,d = map(int, input().split())

while True:
    c -= b
    if c <= 0:
        print("Yes")
        exit()
    a -= d
    if a <= 0:
        print("No")
        exit()

Solution (Python):
A,B,C,D = map(int,input().rstrip().split(" "))
for i in range(100):
    C -= B
    if (C <= 0):
        print("Yes")
        break
    A -= D
    if (A <= 0):
        print("No")
        break

Solution (Python):
H1, A1, H2, A2 = map(int, input().split())
while True:
    H2 -= A1
    if H2 <= 0:
        print("Yes")
        break
    H1 -= A2
    if H1 <= 0:
        print("No")
        break

Solution (Python):

"""
Created on Sun Apr 26 20:56:50 2020

@author: Kanaru Sato
"""

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

takahashiturns = -1*((-1*c)//b)
aokiturns = -1*((-1*a)//d)

if takahashiturns <= aokiturns:
    print("Yes")
else:
    print("No")

Solution (Python):
a,b,c,d = [int(i) for i in input().split()]

while True:
  c -= b
  if c <= 0:
    print('Yes')
    break
  a -= d
  if a <= 0:
    print('No')
    break

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

Solution (Python):
import math
A, B, C, D = map(int, input().split())


if math.ceil(C/B) <= math.ceil(A/D):
    print("Yes")
else:
    print("No")

Solution (Python):
A, B, C, D = list(map(int, input().split()))
while A > 0 and C > 0:
    C -= B
    if not C > 0:
        print('Yes')
        break
    A -= D
    if not A > 0:
        print('No')
        break

Solution (Python):
A, B, C, D = map(int, input().split())

while True:
    C -= B
    if(C <= 0):
        print("Yes")
        break
    A -= D
    if(A <= 0):
        print("No")
        break

Solution (Python):
A, B, C, D = map(int, input().split())
i = 0
while True:
    if i % 2 == 0:
        C -= B
        if C <= 0:
            print("Yes")
            exit()
    else:
        A -= D
        if A <= 0:
            print("No")
            exit()
    i += 1

Solution (Python):
a,b,c,d=map(int,input().split())



mode = 0
cnt = 0
while True:
	mode ^= 1
	if mode == 0:
		a = a - d
		if a <= 0:
			print("No")
			break
	else:
		c = c - b
		if c <= 0:
			print("Yes")
			break

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

Solution (Python):
a,b,c,d = map(int, input().split())

k=(a-1)//d
l=(c-1)//b
if k<l:
   print('No')
else:
   print("Yes")

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

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

Solution (Python):
T_HP,T_ATK,A_HP,A_ATK = [int(i) for i in input().split()]
while 1:
    A_HP -= T_ATK
    if A_HP <1:
        print("Yes")
        break
    T_HP -= A_ATK
    if T_HP <1:
        print("No")
        break

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B, C, D = MAP()

while 1:
    C -= B
    
    if C <= 0:
        print("Yes")
        exit()
    A -= D
    
    if A <= 0:
        print("No")
        exit()

Solution (Python):
a,b,c,d = [int(i) for i in input().split()]
while True:
    c -= b
    if c <= 0:
        print("Yes")
        exit()
    a -= d
    if a <= 0:
        print("No")
        exit()

Solution (Python):
A, B, C, D = map(int, input().split())

while A >= 0 and C >= 0:
    C -= B
    if C <= 0:
        print("Yes")
        break
    A -= D
    if A <= 0:
        print("No")
        break

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


def ceil(a, b):
    return -(-a // b)


x = ceil(c, b)
y = ceil(a, d)
if x <= y:
    print('Yes')
else:
    print('No')

Solution (Python):



from math import *
from copy import *					
from heapq import *					
from string import *				
from random import *				
from bisect import *				
from sys import stdin				
from sys import maxsize				
from operator import *				
from itertools import *				
from collections import Counter		
from collections import defaultdict 

'''

'''

def solve(l):
	f = 1
	h1,s1,h2,s2 = l
	while(h1 > 0 and h2 > 0):
		h2 -= s1
		if(h2 <= 0):
			break
		h1 -= s2
	if(h1 <= 0):
		f = 0
	if(f):
		return 'Yes'
	else:
		return 'No'

l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)

Solution (Python):

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

Solution (Python):

import numpy as np
from collections import deque
a, b, c, d = list(map(int, input().split()))

while (a > 0 and c > 0):
    c -= b
    if (c <= 0):
        print('Yes')
        exit()
    a -= d
    if (a <= 0):
        print('No')
        exit()

Solution (Python):
a,b,c,d=map(int,input().split())
x=c//b+(c%b!=0)
y=a//d+(a%d!=0)
print('Yes' if x<=y else 'No')

Solution (Python):


th, ta, ah, aa = map(int, input().split())

while True:
    ah -= ta
    if ah <= 0:
        print('Yes')
        break
    
    th -= aa
    if th <= 0:
        print('No')
        break

Solution (Python):
A, B, C, D = map(int, input().split())

while True:
    C -= B
    if C <= 0:
        print("Yes")
        exit()

    A -= D
    if A <= 0:
        print("No")
        exit()

Solution (Python):
A, B, C, D = map(int,input().split())

while True:
  C -= B
  if C <= 0:
    ans = 'Yes'
    break
  A -= D
  if A <= 0:
    ans = 'No'
    break
print(ans)

Solution (Python):
a, b, c, d= map(int, input().split())

while True:
  c -= b
  if c<=0:
    print('Yes')
    break
  a -= d
  if a<=0:
    print('No')
    break

Solution (Python):
a, b, c, d = map(int, input().split())

while True:
    c = c - b

    if c <= 0:
        ans = "Yes"
        break

    a = a - d

    if a <= 0:
        ans = "No"
        break

print(ans)

Solution (Python):
import math
A,B,C,D=[int(s) for s in input().split()]
taka=math.ceil(C/(B+0.0))
aoki=math.ceil(A/(D+0.0))
if taka>aoki:
  print('No')
else:
  print('Yes')

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

Solution (Python):

import sys

YES = "Yes"  
NO = "No"  


def solve(A: int, B: int, C: int, D: int):
    while True:
        C -= B
        if C <= 0:
            print(YES)
            break
        A -= D
        if A <= 0:
            print(NO)
            break
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    D = int(next(tokens))  
    solve(A, B, C, D)

if __name__ == '__main__':
    main()

Solution (Python):
a,b,c,d = map(int, input().split())

while 1:
    c -= b
    if c<=0:
        print('Yes')
        break
    a -= d
    if a<=0:
        print('No')
        break

Solution (Python):
a, b, c, d = map(int, input().split())
cnt = 0
while a > 0 and c > 0:
    if cnt % 2 == 0:
        c -= b
    else:
        a -= d
    cnt += 1
print('Yes' if c <= 0 else 'No')

Solution (Python):

import sys

YES = "Yes"  
NO = "No"  


def solve(A: int, B: int, C: int, D: int):
    while True:
        C -= B
        if C <= 0:
            print(YES)
            return
        A -= D
        if A <= 0:
            print(NO)
            return
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    C = int(next(tokens))  
    D = int(next(tokens))  
    solve(A, B, C, D)


if __name__ == '__main__':
    main()

Solution (Python):
A, B, C, D = map(int, input().split())

while True:
    C -= B
    if C <= 0:
        print("Yes")
        break
    A -= D
    if A <= 0:
        print("No")
        break

Solution (Python):
A, B, C, D = map(int, input().split())

takahashi = True
while A > 0 and C > 0:
    if takahashi:
        C -= B
    else:
        A -= D
    takahashi = not takahashi

print("Yes" if A > 0 else "No")

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

while True:
    C -= B
    if C <= 0:
        break

    A -= D
    if A <= 0:
        break

if C <= 0:
    ans = 'Yes'
else:
    ans = 'No'

print(ans)

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

Solution (Python):
a, b, c, d = map(int, input().split())

cnt = 0

while a > 0 and c > 0:
    
    if cnt & 1:
        a -= d
        cnt += 1
    else:
        c -= b
        cnt += 1

print("Yes" if cnt & 1 else "No")

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

while True:
    C -= B
    if C <= 0:
        print("Yes")
        break
    A -= D
    if A <= 0:
        print("No")
        break

Solution (Python):
import math

def makelist(n, m):
    return [[0 for _ in range(m)] for _ in range(n)]





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

while True:
    if ans:
        C -= B
        if C <= 0:
            break
        ans = False
    else:
        A -= D
        if A <= 0:
            break
        ans = True

if ans:
    print("Yes")
else:
    print("No")

Solution (Python):
import sys
range = xrange
input = raw_input

a,b,c,d = [int(x) for x in input().split()]

while True:
    c -= b
    if c <= 0:
        print 'Yes'
        break
    a -= d
    if a <= 0:
        print 'No'
        break

Solution (Python):
a, b, c, d = map(int, input().split())

if c // b + bool(c % b) <= a // d + bool(a % d):
    print('Yes')
else:
    print('No')

Solution (Python):
a, b, c, d = map(int, input().split())
for i in range(100000):
    if i % 2 == 0:
        c -= b
        if c <= 0:
            print('Yes')
            exit()
    else:
        a -= d
        if a <= 0:
            print('No')
            exit()

Solution (Python):
a, b, c, d = map(int, input().split())

t = 0

while a > 0 and c > 0:
    if t % 2 == 0:
        c = c - b
    else:
        a = a - d
    t += 1
if a > 0:
    print("Yes")
else:
    print("No")

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline

A, B, C, D = map(int, read().split())
t = (C + B - 1) // B
a = (A + D - 1) // D
if t <= a:
    print('Yes')
else:
    print('No')

Solution (Python):
a, b, c, d = map(int, input().split())
if (c - 1) // b <= (a - 1) // d:
    print("Yes")
else:
    print("No")

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

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

Solution (Python):
A, B, C, D = [int(i) for i in input().split()]

while A>0 or C>0:
    C=C-B
    if C<=0:
        print("Yes")
        exit()

    A=A-D
    if A<=0:
        print("No")
        exit()

Solution (Python):
def solve():
    a, b, c, d = map(int, input().split())
    for i in range(1000):
        if i % 2 == 0:
            if a <= 0:
                print('No')
                return
            c -= b
        else:
            if c <= 0:
                print('Yes')
                return
            a -= d


if __name__ == '__main__':
    solve()

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

Solution (Python):
import sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
MD2 = lambda d1,d2: [[INIT_VAL]*d2 for _ in range(d1)]
MD3 = lambda d1,d2,d3: [MD2(d2,d3) for _ in range(d1)]

DIVC = lambda x,y: -(-x//y)
DIVF = lambda x,y: x//y

def main():
    a,b,c,d = MII()
    ta = DIVC(c,b)
    ao = DIVC(a,d)
    if ta <= ao: print('Yes')
    else: print('No')

if __name__ == '__main__':
    main()

Solution (Python):
a,b,c,d=map(int,input().split())
x=(a-1)//d
y=(c-1)//b
print("Yes" if x>=y else "No")

Solution (Python):
from sys import stdin
A,B,C,D = [int(x) for x in stdin.readline().rstrip().split()]
while True:
    C -= B
    if C <= 0:
        print("Yes")
        break
    A -= D
    if A <= 0:
        print("No")
        break

Solution (Python):
a,b,c,d = map(int,input().split())

for i in range(10000):
    c -= b
    if c <= 0:
        print('Yes')
        break
    
    a -= d
    if a <= 0:
        print('No')
        break

Solution (Python):
import math
A,B,C,D = list(map(int,input().split()))
after_A = math.ceil(A/D)
after_B = math.ceil(C/B)
if after_A < after_B:
    print("No")
else:
    print("Yes")

Solution (Python):
a,b,c,d = map(int,input().split())

taka = (c+(b-1)) // b
aoki = (a+(d-1)) // d

if taka <= aoki:
    print('Yes')
else:
    print('No')

Solution (Python):
A, B, C, D = map(int, input().split())

while True:
    C -= B
    if C <= 0:
        print('Yes')
        break
    A -= D
    if A <= 0:
        print('No')
        break

Solution (Python):
A,B,C,D=map(int,input().split())
i=0
while(A>0 and C>0):
    if(i%2==0):
        C-=B
    else:
        A-=D
    if(A<=0 or C<=0):
        if(i%2==0):
            print('Yes')
        else:
            print('No')
        exit()
    i+=1

Solution (Python):
l = [int(x) for x in input().split(" ")]
from math import ceil
if ceil(l[2]/l[1]) <= ceil(l[0]/l[3]):
  print("Yes")
else:
  print("No")

Solution (Python):

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

if -(-C//B)<=-(-A//D):
    print("Yes")
else:
    print("No")

Solution (Python):


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

for i in range(10000):
    if i % 2 == 0:
        c -= b
    else:
        a -= d
    if a <= 0:
        print('No')
        break
    if c <= 0:
        print('Yes')
        break

Solution (Python):
A, B, C, D = map(int, input().split())

while True:
    C -= B
    if C <= 0:
        print('Yes')
        break
    A -= D
    if A <= 0:
        print('No')
        break

Solution (Python):
import sys
from math import log2,floor,ceil,sqrt


sys.setrecursionlimit(7*10**4)

Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
 
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 18
MOD =  998244353


a,b,c,d   = Ri()
tt = ceil(c/b)
ot = ceil(a/d)

if ot < tt:
    No()
else:
    Yes()

Solution (Python):
import sys
a,b,c,d=map(int,input().split())
while True:
    c-=b
    if c<=0:
        print("Yes")
        sys.exit()
    a-=d
    if a<=0:
        print("No")
        sys.exit()

Solution (Python):
import math

a,b,c,d = (int(x) for x in input().split())

takahashi = math.ceil(a/d)
aoki = math.ceil(c/b)

if takahashi>=aoki:
    print("Yes")
else:
    print("No")

Solution (Python):
A,B,C,D= map(int,input().split())

result = None
while True:
    C -= B
    if C <= 0:
        result = 'Yes'
        break
    A -= D
    if A <= 0:
        result = 'No'
        break

print(result)

Solution (Python):
a,b,c,d =map(int,input().split())
tkhs=(c+b-1)//b
aok=(a+d-1)//d
print('Yes' if(tkhs<=aok) else 'No')

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

Solution (Python):
import bisect
import copy
import heapq
import math
import sys
from collections import *
from itertools import accumulate, combinations, permutations, product
from math import gcd
def input():
    return sys.stdin.readline()[:-1]
def ruiseki(lst):
    return [0]+list(accumulate(lst))
mod=pow(10,9)+7
al=[chr(ord('a') + i) for i in range(26)]
direction=[[1,0],[0,1],[-1,0],[0,-1]]

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

cnt=0
while a>0 and c>0:
    if cnt%2==0:
        c-=b
    else:
        a-=d
    if a<=0:
        print("No")
    elif c<=0:
        print("Yes")
    cnt+=1

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

Solution (Python):
a, b, c, d = map(int, input().split())

for i in range(10 ** 5):
    c -= b
    if c <= 0:
        print('Yes')
        exit()
    a -= d
    if a <= 0:
        print('No')
        exit()

Solution (Python):
import math

a, b, c, d = map(int,input().split())
tak=math.ceil(a/d)
aok=math.ceil(c/b)
if tak>aok:
    print("Yes")
elif tak<aok:
    print("No")
else:
    print("Yes")

Solution (Python):
a,b,c,d = map(int,input().split())

while(True):
    c -= b
    if c <= 0:
        print("Yes")
        quit()
    a -= d
    if a <= 0:
        print("No")
        quit()

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

a,b,c,d = LI()

while 1:
    if c - b <= 0:
        print('Yes')
        quit()
    if a - d <= 0:
        print('No')
        quit()
    c -= b
    a -= d

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline


def solve():
    A, B, C, D = map(int, rl().split())
    for i in range(200):
        if i % 2 == 0:
            C -= B
            if C <= 0:
                print('Yes')
                exit()
        else:
            A -= D
            if A <= 0:
                print('No')
                exit()


if __name__ == '__main__':
    solve()

Solution (Python):
import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def resolve():
    A, B, C, D = lr()
    cnt = 0
    while A > 0 and C > 0:
        if cnt == 0:
            cnt = 1
            C -= B
        else:
            cnt = 0
            A -= D
    if A <= 0:
        print('No')
    else:
        print('Yes')
resolve()

Solution (Python):
a,b,c,d =map(int,input().split())

while True:
    c-=b
    if c<=0:
        print("Yes")
        break
    
    a-=d
    if a<=0:
        print("No")
        break

Solution (Python):
a,b,c,d=[int(i) for i in input().split()]

i=0
while True:
    if i==0:
        c-=b
        if c<=0:
            print("Yes")
            break
        else:
            i=1
            i=i%2
    else:
        a-=d
        if a<=0:
            print("No")
            break
        else:
            i=0

Solution (Python):
import sys
sys.setrecursionlimit(10000)

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


if __name__ == "__main__":
    main()

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

print(ans)

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

while True:
    C -= B
    if C <= 0:
        print("Yes")
        exit()
    A -= D
    if A <= 0:
        print("No")
        exit()

Solution (Python):


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

while True:
    c-=b
    if c<=0:
        print("Yes")
        break
    a-=d
    if a<=0:
        print("No")
        break

Solution (Python):
a,b,c,d = map(int,input().split())
f=0
while(1):
    c-=b
    if c<=0:
        f=1
        break
    a-=d
    if a<=0:
        f=2
        break

if f==1:
    print('Yes')
else:
    print('No')

Solution (Python):
A, B, C, D = map(int, input().split())

while True:
    C -= B
    if C <= 0:
        print("Yes")
        break
    A -= D
    if A <= 0:
        print("No")
        break

Solution (Python):
a, b, c, d = map(int, input().split())

while (0 < a) or (0 < c):
    c -= b
    if (c <= 0):
        print('Yes')
        break
    a -= d
    if (a <= 0):
        print('No')
        break

Solution (Python):
import sys,os
from collections import defaultdict, deque
from math import ceil, floor
if sys.version_info[1] >= 5:
    from math import gcd
else:
    from fractions import gcd
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    MOD = 10**9+7

    A,B,C,D = LMIIS()
    t = True
    while A > 0 and C > 0:
        if t :
            C -= B
        else:
            A -= D
        t ^= True
    if t:
        print('No')
    else:
        print('Yes')


if __name__ == '__main__':
    main()

Solution (Python):
import sys
import math
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    A, B, C, D =map(int, readline().split())
    if math.ceil(C/B)<=math.ceil(A/D):
        print('Yes')
    else:
        print('No')


if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline


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


if __name__ == '__main__':
    main()

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

Solution (Python):
import sys
from io import StringIO
import unittest


def resolve():
    a, b, c, d = map(int, input().split())

    win = False

    while 1:
        c -= b

        if c <= 0:
            win = True
            break

        a -= d

        if a <= 0:
            break

    if win:
        print('Yes')
    else:
        print('No')

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """10 9 10 10"""
        output = """No"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """46 4 40 5"""
        output = """Yes"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

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

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

Solution (Python):
A, B, C, D = map(int, input().split())
ans = True
while True:
    C-=B
    if C <= 0:
        break
    A-=D
    if A <= 0:
        ans = False
        break
if ans:
    print('Yes')
else:
    print('No')

Solution (Python):
A, B, C, D = [int(i) for i in input().split()]
while True:
    C -= B
    if C <= 0:
        ans = 'Yes'
        break
    A -= D
    if A <= 0:
        ans = 'No'
        break
print(ans)

Solution (Python):
A,B,C,D=map(int,input().split())
if(C%B==0):tak=C//B
else:tak=C//B+1
if(A%D==0):aok=A//D
else:aok=A//D+1
if(aok>=tak):print("Yes")
else:print("No")

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

Solution (Python):
import math
A, B, C, D = list(map(int, input().split()))

a = math.ceil(C/B)
b = math.ceil(A/D)

if b >= a:
    print("Yes")
else:
    print("No")

Solution (Python):

import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from decimal import *
from collections import deque
from math import gcd
sys.setrecursionlimit(10**7)
MOD = 10**9+7
INF = float('inf') 
def lcm(a,b):return (a*b) // gcd(a,b) 
def iin(): return int(sys.stdin.readline()) 
def ifn(): return float(sys.stdin.readline()) 
def isn(): return sys.stdin.readline().split() 
def imn(): return map(int, sys.stdin.readline().split()) 
def imnn(): return map(lambda x:int(x)-1, sys.stdin.readline().split()) 
def fmn(): return map(float, sys.stdin.readline().split()) 
def iln(): return list(map(int, sys.stdin.readline().split())) 
def iln_s(): return sorted(iln()) 
def iln_r(): return sorted(iln(), reverse=True) 
def fln(): return list(map(float, sys.stdin.readline().split())) 
def join(l, s=''): return s.join(l) 
def perm(l, n): return itertools.permutations(l, n) 
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) 
def comb(l, n): return itertools.combinations(l, n) 
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 
def m_add(a,b): return (a+b) % MOD
def lprint(l): print(*l, sep='\n')

A,B,C,D = imn()

while A >= 0 and C >= 0:
    C -= B
    if C <= 0:
        print('Yes')
        break
    A -= D
    if A <= 0:
        print('No')
        break

Solution (Python):
a, b, c, d = map(int, input().split())

turn = 1
while a > 0 and c > 0:
    if turn == 1:
        c -= b
    else:
        a -= d
    turn *= -1

if a <= 0:
    print("No")
else:
    print("Yes")

Solution (Python):
a,b,c,d = map(int, input().split())
for i in range(100000):
    c -= b
    if (c <= 0):
        print("Yes")
        exit()
    a -= d
    if (a <= 0):
        print("No")
        exit()

Solution (Python):
a,b,c,d=map(int,input().split())
i=0
while True:
    if i%2==0:
        c=c-b
    else:
        a=a-d
    i+=1
    
    if a<=0:
        print("No")
        break
    elif c<=0:
        print("Yes")
        break

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

Solution (Python):
a, b, c, d = map(int, input().split())

while True:
    c -= b
    if c <= 0:
        print('Yes')
        break

    a -= d
    if a <= 0:
        print('No')
        break