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

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

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

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

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

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

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

Difficulty: introductory

Starter code:

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

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

while A > 0 and C > 0:
    A -= D
    C -= B

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

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

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

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



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

while A > 0 and C > 0:
    A -= D
    C -= B

if C <= 0:
    print('Yes')
else:
    print('No')

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

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

ta = a
ao = c

while ta > 0 and ao > 0:
  ao = ao - b
  ta = ta - d
  
  if ao <= 0:
    print('Yes')  
  elif ta <= 0:
    print('No')
    return

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

if c % b == 0:
    t = c / b
else:
    t = (c // b) + 1

if a % d == 0:
    o = a / d
else:
    o = (a // d) + 1

if t > o:
    print("No")
elif t <= o:
    print("Yes")

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


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

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

    def battle(self):
        while True:
            self.calc_damage(0, 1)
            if self.monsters[1].death:
                print("Yes")
                break
            self.calc_damage(1, 0)
            if self.monsters[0].death:
                print("No")
                break


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

t_monster = Monster(a, b)
a_monster = Monster(c, d)

game = Game([t_monster, a_monster])
game.battle()

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

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

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

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

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

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


A,B,C,D = list(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



import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp

INF = inf
MOD = 1000000007

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

tmp = 0
res = "No"

while True:
    c -= b
    if c <= 0:
        res = "Yes"
        break
    a -= d
    if a <= 0:
        break

print(res)


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


class Monster:
    def __init__(self, life, power):
        self.life = life
        self.power = power


takahasi = Monster(A, B)
aoki = Monster(C, D)

while takahasi.life > 0 and aoki.life > 0:
    AHP = aoki.life - takahasi.power
    aoki.life = AHP
    THP = takahasi.life - aoki.power
    takahasi.life = THP
    if AHP <= 0:
        print("Yes")
        break
    if THP <= 0:
        print("No")
        break

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

while a>0 and c>0:
  c-=b
  if c<=0:
    answer="Yes"
  a-=d

    
print(answer)

'''
問題：
    高橋君と青木君がモンスターを闘わせます。

    高橋君のモンスターは体力が A で攻撃力が B です。
    青木君のモンスターは体力が C で攻撃力が D です。

    高橋君→青木君→高橋君→青木君→... の順に攻撃を行います。
    攻撃とは、相手のモンスターの体力の値を自分のモンスターの攻撃力のぶんだけ減らすことをいいます。
    このことをどちらかのモンスターの体力が 0 以下になるまで続けたとき、
    先に自分のモンスターの体力が 0 以下になった方の負け、そうでない方の勝ちです。

    高橋君が勝つなら Yes、負けるなら No を出力してください。
'''

'''
制約：
    1 ≦ A, B, C, D ≦ 100
    入力は全て整数である
'''
class Monster:
    def __init__(self, hp, power):
        self.hp = hp
        self.power = power

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

    def is_loser(self)   -> bool:
        return self.hp <= 0

# 標準入力から A, B, C, D を取得する
a, b, c, d = list(map(int, input().split()))

takahashi_monster = Monster(a, b)   # 高橋モンスター
aoki_monster = Monster(c, d)    # 青木モンスター
result = "ret"

while True:
    aoki_monster.fight(b)   # 高橋の攻撃
    if aoki_monster.is_loser():
        result = "Yes"
        break

    takahashi_monster.fight(d)  # 青木の攻撃
    if takahashi_monster.is_loser():
        result = "No"
        break

print(result)


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

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

        A -= D
        if A <= 0:
            return "No"
            break

print((answer(A, B, C, D)))


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

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
#from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
import sys

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

A, B, C, D = na()
t = (C + B - 1) // B 
a = (A + D - 1) // D 
print('Yes') if t <= a else print('No')

#モンスターのデータ
class Monster:
    def __init__(self,hp,at):
        self.hp = hp
        self.at = at

#「戦闘」を定義。値の推移
    def fight(self,at)->int:
        self.hp -=at
        return self.hp
#hpからatを引く。その値を再びhpに返す

#「敗北」を定義する
    def is_loser(self)-> bool:
        return self.hp <=0


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

takahashi_monster= Monster(A,B)
aoki_monster = Monster(C,D)


while True:
    aoki_monster.fight(B)     #高橋の攻撃
    if aoki_monster.is_loser():
        result = 'Yes'
        break

    takahashi_monster.fight(D)  #青木の攻撃
    if takahashi_monster.is_loser():
        result = 'No'
        break

print(result)

t_hp, t_atk, a_hp, a_atk = list(map(int, input().split()))

t_count = 0
a_count = 0

while a_hp > 0:
    a_hp -= t_atk
    t_count += 1

while t_hp > 0:
    t_hp -= a_atk
    a_count += 1

if t_count <= a_count:
    print('Yes')
else:
    print('No')




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

m = C // B  # 青木君の耐えうるターン
if C % B != 0:
    m = m + 1

n = A // D  # 高橋君の耐えうるターン
if A % D != 0:
    n = n + 1

if n >= m:
    print('Yes')
else:
    print('No')


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

while A > 0 and C > 0:
    A -= D
    C -= B

if C <= 0:
    print('Yes')
else:
    print('No')

a,b,c,d = map(int,input().split())
# 高橋君の倒すまでの攻撃回数
takahashi_turn = 0
# 青木君の倒すまでの攻撃回数
aoki_turn = 0
# 攻撃するたびに回数カウントして体力を減らす
while c - b > 0:
    takahashi_turn += 1
    c -= b
while a - d > 0:
    aoki_turn += 1
    a -= d
# 高橋くんが早く倒すときはYes
if takahashi_turn <= aoki_turn:
    print("Yes")
else:
    print("No")

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

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

turn = 0
while A > 0 and C > 0:
    if turn == 0:
        C -= B
        turn = 1
    else:
        A -= D
        turn = 0

if A <= 0:
    print('No')
else:
    print('Yes')


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

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


# 高橋君のモンスターは体力が A で攻撃力が B 
# 青木君のモンスターは体力が C で攻撃力が D 
# モンスターの体力が 0 以下になった方の負け、
# 高橋君が勝つなら Yes、負けるなら No を出力

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

# 高橋君のモンスター　体力A、攻撃力B
# 青木君のモンスター　体力C、攻撃力D
# 高橋->青木->高橋->青木->...の順に攻撃する
# 高橋勝つならYes、負けるならNo

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

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

while A > 0 and C > 0:
    C -= B
    A -= D

if C <= 0:
    print('Yes')
else:
    print('No')


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


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

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

    def battle(self):
        while True:
            self.calc_damage(0, 1)
            if self.monsters[1].death:
                print("Yes")
                break
            self.calc_damage(1, 0)
            if self.monsters[0].death:
                print("No")
                break


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

t_monster = Monster(a, b)
a_monster = Monster(c, d)

game = Game([t_monster, a_monster])
game.battle()

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(map(int, input().split()))
def i_row(N): return [int(input()) for _ in range(N)]
def i_row_list(N): return [list(map(int, input().split())) for _ in range(N)]

tHP, tATK,aHP,aATK=i_map()
while True:
    aHP=max(aHP-tATK,0)
    if aHP==0:
        ans='Yes'
        break
    tHP = max(tHP - aATK, 0)
    if tHP==0:
        ans='No'
        break
print(ans)

import math

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

T_kougeki = C / B
A_kougeki = A / D     

if math.ceil(T_kougeki) <= math.ceil(A_kougeki):       print('Yes')

else:
    print('No')

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

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

    def is_loser(self)   -> bool:
        return self.hp <= 0

# 標準入力から A, B, C, D を取得する
a, b, c, d = map(int, input().split())

takahashi_monster = Monster(a, b)   # 高橋モンスター
aoki_monster = Monster(c, d)    # 青木モンスター
result = "ret"

while True:
    aoki_monster.fight(b)   # 高橋の攻撃
    if aoki_monster.is_loser():
        result = "Yes"
        break
    else:
        pass

    takahashi_monster.fight(d)  # 青木の攻撃
    if takahashi_monster.is_loser():
        result = "No"
        break
    else:
        pass

print(result)

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

for i in range(220):
    if i % 2 == 0:
        c -= b
    else:
        a -= d

    if c <= 0:
        print('Yes')
        return
    elif a <= 0:
        print('No')
        return


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

result = 'Yes'

while A > 0 or C > 0:
    C -= B
    A -= D
    if C <= 0:
        break
    elif A <= 0:
        result = 'No'
        break

print(result)

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

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

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

class Monster:
    def __init__(self,life,power):
        self.life = life
        self.power = power

takahasi = Monster(A,B)
aoki = Monster(C,D)

while takahasi.life > 0 and aoki.life > 0:
    AHP = aoki.life - takahasi.power
    aoki.life = AHP
    THP = takahasi.life - aoki.power
    takahasi.life = THP
    if AHP <= 0:
        print("Yes")
        break
    if THP <= 0:
        print("No")
        break

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

result = 'Yes'

while A > 0 or C > 0:
    C -= B
    A -= D
    if C <= 0:
        break
    elif A <= 0:
        result = 'No'
        break

print(result)

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

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

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

x = math.ceil(a / d)
z = math.ceil(c / b)

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

print(result())

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

tkhp,tkat,aohp,aoat = list(map(int,input().split()))

while True:
    aohp -= tkat
    if aohp <= 0:
        print('Yes')
        break
        
    tkhp -= aoat
    if tkhp <= 0:
        print('No')
        break

import math

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

while True:
    C -= B

    if C <= 0:
        print('Yes')
        break

    A -= D

    if A <= 0:
        print('No')
        break


def main() -> None:
    a, b, c, d = list(map(int, input().split()))

    if a % d == 0:
        turn_t = a // d
    else:
        turn_t = a // d + 1
    if c % b == 0:
        turn_a = c // b
    else:
        turn_a = c // b + 1
    print(('Yes' if turn_a <= turn_t else 'No'))
    return


def __starting_point():
    main()

__starting_point()

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

a,b,c,d=map(int, input().split())
t_1=(a+d-1)//d
t_2=(c+b-1)//b
print("Yes" if t_2<=t_1 else "No")

# coding=utf-8
import sys

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

    while True:
        C -= B
        if C <= 0:
            print('Yes')
            return

        A -= D
        if A <= 0:
            print('No')
            return

__starting_point()

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

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

#   Battle

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


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

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

    def battle(self):
        while True:
            self.calc_damage(0, 1)
            if self.monsters[1].death:
                print("Yes")
                break
            self.calc_damage(1, 0)
            if self.monsters[0].death:
                print("No")
                break


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

t_monster = Monster(a, b)
a_monster = Monster(c, d)

game = Game([t_monster, a_monster])
game.battle()


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

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

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

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

while A > 0 and C > 0:
    A -= D
    C -= B

if C <= 0:
    print('Yes')

else:
    print('No')

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


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

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

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

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

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


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


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

taka = 0
aoki = 0

while A > 0:
    A -= D
    taka += 1
    
while C > 0:
    C -= B
    aoki += 1
    
if taka >= aoki:
    print("Yes")
else:
    print("No")

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

while A > 0 and C > 0:
    C -= B
    A -= D

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

import sys

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

for _ in range(100):
    a_t = c-b
    if a_t <= 0:
        print('Yes')
        return
    c = a_t
    
    t_t = a-d
    if t_t <= 0:
        print('No')
        return

    a = t_t

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

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


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

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

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

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

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

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

def __starting_point():

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

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

__starting_point()

N = list(map(int,input().split()))
flag = 0
while(N[0] > 0 and N[2] > 0):
  N[2]=N[2]-N[1]
  if(N[2] <= 0):
    flag = 1
    break
  else:
    N[0] = N[0] - N[3]
    if(N[0] <= 0):
      break
if(flag == 1):print("Yes")
else:print("No")

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

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

while A > 0 and C > 0:
    A -= D
    C -= B

if C <= 0:
    print('Yes')
else:
    print('No')

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

class Monster:
    def __init__(self, life, power):
        self.life = life
        self.power = power

def answer(A: int, B: int, C: int, D: int) -> str:
    takahasi = Monster(A, B)
    aoki = Monster(C, D)

    while takahasi.life > 0 and aoki.life > 0:
        A_HP = aoki.life - takahasi.power
        aoki.life = A_HP
        T_HP = takahasi.life - aoki.power
        takahasi.life = T_HP
        if A_HP <= 0:
            return "Yes"
            break
        if T_HP <= 0:
            return "No"
            break

print(answer(A, B, C, D))

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

while a > 0 and c > 0:
    a = a - d
    c = c - b

if c <= 0:
    print('Yes')
else:
    print('No')

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

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

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

x = math.ceil(a / d)
z = math.ceil(c / b)

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

print(result())

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
#from operator import itemgetter
#from heapq import heappush, heappop
#import numpy as np
#from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
import sys

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

A, B, C, D = na()
t = C // B if C % B == 0 else C // B + 1
a = A // D if A % D == 0 else A // D + 1
print('Yes') if t <= a else print('No')

tkhp, tkat, aohp, aoat = map(int,input().split())

while True:
    aohp -= tkat
    if aohp <= 0:
        print("Yes")
        break

    tkhp -= aoat
    if tkhp <= 0:
        print("No")
        break

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

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

x = math.ceil(a / d)
z = math.ceil(c / b)

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

print(result())

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

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        

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

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

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

print((answer(a, b, c, d)))



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

while A > 0 and C > 0:
    A = A - D
    C = C - B

if C <= 0:
    print('Yes')
else:
    print('No')

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


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

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

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

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

# 高橋君のモンスターは体力が A で攻撃力が B です。  a-d
# 青木君のモンスターは体力が C で攻撃力が D です。  c-b

takahashi_hp = a
aoki_hp = c

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

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

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

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

"""
高橋君と青木君がモンスターを闘わせます。
高橋君のモンスターは体力が A で攻撃力が B です。
青木君のモンスターは体力が C で攻撃力が D です。
高橋君→青木君→高橋君→青木君→... の順に攻撃を行います。
攻撃とは、相手のモンスターの体力の値を自分のモンスターの攻撃力のぶんだけ減らすことをいいます。
このことをどちらかのモンスターの体力が 0 以下になるまで続けたとき、
先に自分のモンスターの体力が 0 以下になった方の負け、そうでない方の勝ちです。
高橋君が勝つなら Yes、負けるなら No を出力してください。
"""

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

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


N = list(map(int,input().split()))
flag = 0
while(N[0] > 0 and N[2] > 0):
  N[2]=N[2]-N[1]
  if(N[2] <= 0):
    flag = 1
    break
  else:
    N[0] = N[0] - N[3]
    if(N[0] <= 0):
      break
if(flag == 1):print("Yes")
else:print("No")

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

result = 'Yes'

while A > 0 or C > 0:
    C -= B
    A -= D
    if C <= 0:
        break
    elif A <= 0:
        result = 'No'
        break

print(result)