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):
A,B,C,D=map(int,input().split())
while A>=0 and C>=0:
    C-=B
    if C<=0:
        break
    A-=D

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

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):
MOD = 10 ** 9 + 7
INF = 10 ** 10
import sys
sys.setrecursionlimit(100000000)
dy = (-1,0,1,0)
dx = (0,1,0,-1)

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

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

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

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

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:
            ans = "Yes"
            break
        A -= D
        if A <= 0:
            ans = "No"
            break

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
def examA():
    S, W = LI()
    if S<=W:
        print("unsefe")
    else:
        print("safe")
    return

def examB():
    A, B, C, D = LI()
    while(True):
        C -= B
        if C<=0:
            print("Yes")
            break
        A -= D
        if A<=0:
            print("No")
            break
    return

def examC():
    ans = 0
    print(ans)
    return

def examD():
    ans = 0
    print(ans)
    return

def examE():
    ans = 0
    print(ans)
    return

def examF():
    ans = 0
    print(ans)
    return

import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(readline())
def LI(): return list(map(int,readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]

sys.setrecursionlimit(10**7)

if __name__ == '__main__':
    examB()

"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""

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):
import sys
readline = sys.stdin.readline

def main():
    A, B, C, D = map(int, readline().rstrip().split())
    for i in range(1000):
        if C <= B:
            print('Yes')
            return
        C -= B
        if A <= D:
            print('No')
            return
        A -= D


if __name__ == '__main__':
    main()

Solution (Python):
a,b,c,d = map(int, input().split())
takahashi = 1
while True:
    if takahashi:
        c -= b
    else:
        a -= d
    takahashi = 1- takahashi 
    if c <= 0:
        print("Yes")
        exit()
    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')
        exit()

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

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil,floor,sqrt


import bisect
import re
import heapq


from copy import deepcopy
import itertools

from sys import exit

ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

yes = "Yes"
no = "No"

def main():
    a,b,c,d = mi()
    while True:
        c-=b
        a-=d
        if c<=0:
            print(yes)
            exit()
        if a<=0:
            print(no)
            exit()




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

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

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

Solution (Python):
a,b,c,d=map(int,input().split())
num=1
while a>0 and c>0:
    if num%2==1:
        c=c-b
    else:
        a=a-d
    num+=1
print("Yes" if 0<a else "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):


import sys
stdin = sys.stdin

def ns(): return stdin.readline().rstrip()
def ni(): return int(ns())
def na(): return list(map(int, stdin.readline().split()))

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

if __name__ == "__main__":
    main()

Solution (Python):
import sys

if __name__ == '__main__':
    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 A > 0 else 'No')

Solution (Python):
import sys

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

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

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



debug=1
def pront(*n):
    if debug==1:
        print(n)
        


base=10**9+7

def add(a,b):
    return (a+b)%base

def sub(a,b):
    return (a-b)%base

def multi(a,b):
    return (a*b)%base

def exp(a,b):
    x=1
    c=a
    d=b
    while d!=0:
        if d%2==1:
            x=multi(x,c)
        c=(c**2)%base
        d=d//2
    return x

def div(a,b):
    return(multi(a,exp(b,base-2)))



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
input=sys.stdin.readline
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())

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 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())
while True:
  c -= b
  if c <= 0:
    print('Yes')
    break
  a -= d
  if a <= 0:
    print('No')
    break

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

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

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):
import sys
import math
import collections
from collections import deque
from functools import reduce
import heapq

a, b, c, d = map(int, sys.stdin.readline().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:
    if a <= 0:
        print("No")
        exit()
    else:
        c -= b
    if c <= 0:
        print("Yes")
        exit()
    else:
        a -= d

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

for i in range(100000):
    if i%2==0:
        C-=B
        if C<=0:
            flag = True
            break
    else:
        A-=D
        if A<=0:
            flag = False
            break

if flag:
    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:
        break
    A -= D
print("Yes" if A > 0 else "No")

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

t1 = (c + (b - 1)) // b
t2 = (a + (d - 1)) // d

ans = 'Yes' if t1 <= t2 else 'No'
print(ans)

Solution (Python):
import sys
import math
from collections import deque
import heapq
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

a,b,c,d = IL()

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

Solution (Python):

import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

A, B, C, D = lr()
time1 = (A+D-1) // D
time2 = (C+B-1) // B
bl = time1 >= time2
print('Yes' if bl else 'No')

Solution (Python):
import math

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

if math.ceil(a / d) < math.ceil(c / b):
    print('No')
else:
    print('Yes')

Solution (Python):
def main():

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

if __name__ == '__main__':
    print(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())
import math
if math.ceil(c/b)<=math.ceil(a/d):
    print("Yes")
else:
    print("No")

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby, product
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    import math

    
    

    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

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

while a>=-1 or c>=-1:
    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())


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

Solution (Python):

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

Solution (Python):
a,b,c,d=[int(j) for j in input().split()]
p=-(-c//b)
q=-(-a//d)
if p<=q:
    print("Yes")
else:
    print("No")

Solution (Python):

import sys
input = sys.stdin.buffer.readline


from collections import defaultdict

con = 10 ** 9 + 7

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


def main():
	A, B, C, D = getlist()
	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')
    exit()
  a-=d
  if a<=0:
    print('No')
    exit()

Solution (Python):
a,b,c,d = map(int,input().split())
if (c + b-1)//b <= (a + d - 1)//d:
    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):
import sys
input = sys.stdin.readline

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

while True:
    for i in range(2):
        if i == 0:
            c -= b
            if c <= 0:
                print("Yes")
                sys.exit()
        else:
            a -= d
            if a <= 0:
                print("No")
                sys.exit()

Solution (Python):
a,b,c,d = map(int,input().split())
while 1:
    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())
turn=0
while A>0 and C>0:
    if turn%2==0:
        C-=B
    else:
        A-=D
    turn+=1


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

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    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):
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):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

a,b,c,d = mi()
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=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 A > 0 or 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())

t1 = (C-1)//B + 1
t2 = (A-1)//D + 1

if t1<=t2:
    print("Yes")
else:
    print("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:
            return YES
        A -= D
        if A <= 0:
            return NO
    raise



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))  
    print(solve(A, B, C, D))

if __name__ == '__main__':
    main()

Solution (Python):
import math

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

if math.ceil(inp[2]/inp[1]) <= math.ceil(inp[0]/inp[3]):
    print("Yes")
else:
    print("No")

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())
takahashi_turn = c // b if c % b == 0 else c // b + 1
aoki_turn = a // d if a % d == 0 else a // d + 1
if takahashi_turn <= aoki_turn:
    print('Yes')
else:
    print('No')

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

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

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

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

print("No")

Solution (Python):
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

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


while 1:
    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())
for i in range(100):
         c = c - b
         if c <= 0:
                  print("Yes")
                  exit()
         a = 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())
i = 0
while a>0 and c>0:
    if i%2==0:
        c -= b
    else:
        a -= d
    i += 1

if a < c:
    print("No")
else:
    print("Yes")

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

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

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

main()

Solution (Python):
def Int():
    return int(input())
def Ints():
    return map(int,input().split())
def IntList():
    return list(Ints())
def IntMat(N):
    return [IntList() for i in range(N)]

A,B,C,D = Ints()
now = 0
while A>0 and C>0:
    if now%2==0:
        C-=B
    else:
        A -= D
    now += 1
if A<=0:
    print('No')
else:
    print('Yes')

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

def inputlist(): return [int(k) for k in input().split()]

A,B,C,D = inputlist()
ta = 0
ao = 0
if C % B == 0:
    ta = C//B
if C % B != 0:
    ta = (C//B)+1
if A % D == 0:
    ao = A//D
if A % D != 0:
    ao = (A//D)+1
if ta <= ao:
    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 True:
    if a <= 0:
        print("No")
        exit()
    elif c <= 0:
        print("Yes")
        exit()
    if i % 2 == 0:
        c -= b
    else:
        a -= d
    i += 1

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 1:
  c -= b
  if c<=0:
    print('Yes')
    break
  a -= d
  if a <= 0:
    print('No')
    break

Solution (Python):
import sys
stdin = sys.stdin
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

a,b,c,d = na()

if (a-1)//d >= (c-1)//b:
    print('Yes')
else:
    print('No')

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):
mod = 1000000007
eps = 10**-9


def main():
    import sys
    input = sys.stdin.readline

    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):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

a, b, c, d = map(int, readline().split())
for i in range(10000):
    c -= b
    if c <= 0:
        print('Yes')
        break
    a -= d
    if a <= 0:
        print('No')
        break

Solution (Python):
def main():
    a,b,c,d=map(int,input().split())
    while a>0 or c>0:
        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 = list(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())

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

for _ in range(1000000):
    if A <= 0:
        print('No')
        break
    C -= B
    if C <= 0:
        print('Yes')
        break
    A -= D

Solution (Python):
def main():
    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


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):
def main():
    a, b, c, d = map(int, input().split())

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


if __name__ == '__main__':
    main()

Solution (Python):

import sys
import math
sys.setrecursionlimit(10**8)
INF = float("inf")


def yes():
    print("Yes")  


def no():
    print("No")  


def solve(A: int, B: int, C: int, D: int):

    if math.ceil(C/B) <= math.ceil(A/D):
        yes()
    else:
        no()
    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):
def input_int():
    return int(input())

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

A, B, C, D = input_ints()

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

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

if t1 <= t2:
  print('Yes')
else:
  print('No')

Solution (Python):

import sys
input = sys.stdin.readline

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

YES = "Yes"  
NO = "No"  


def solve(A: int, B: int, C: int, D: int):
    while True:
        C -= B
        if C <= 0:
            print(YES)
            exit()
        A -= D
        if A <= 0:
            print(NO)
            exit()
    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):

import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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):
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 = 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 sys

sys.setrecursionlimit(10 ** 8)

input = sys.stdin.readline


def main():
    A, B, C, D = [int(x) for x in input().split()]

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



if __name__ == '__main__':
    main()

Solution (Python):

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

import sys
while True:

    C -= B

    if C <= 0:
        print ("Yes")
        sys.exit()

    A -= D

    if A <= 0:
        print ("No")
        sys.exit()

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B, C, D = MAP()

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

Solution (Python):
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return map(int, sys.stdin.readline().split())
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]




A, B, C, D = mi()

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 1:
    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')
        exit(0)
    a -= d
    if a <= 0:
        print('No')
        exit(0)

Solution (Python):
import sys
import math
import fractions
from collections import deque
from collections import defaultdict
sys.setrecursionlimit(10**7)

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 1:
    C -= B
    if C <= 0:
        print("Yes")
        exit()
    A -= D
    if A <= 0:
        print("No")
        exit()

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

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

if __name__ == '__main__':
    main()

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):
A,B,C,D=map(int,input().split())

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

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

ta = (c+b-1) // b
ao = (a+d-1) // d

if ta <= ao:
    print("Yes")
else:
    print("No")

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

T = C // B
O = A // D

if C % B != 0:
  T += 1
if A % D != 0:
  O += 1

if T <= O:
  print("Yes")
else:
  print("No")

Solution (Python):
import math

h1, s1, h2, s2 = map(int, input().split())

while True:
    h2 -= s1
    if h2 <= 0:
        print('Yes')
        break
    h1 -= s2
    if h1 <= 0:
        print('No')
        break

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

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

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
     
def main():
    a, b, c, d = LI()
    while True:
        c -= b
        if c <= 0:
            win = "Yes"
            break
        a -= d
        if a <= 0:
            win = "No"
            break
    print(win)
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