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

Solution (Python):

import sys

YES = "Yes"  
NO = "No"  


def solve(A: int, B: int, C: int, D: int):
    for i in range(110):
        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):
import math

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

tn = math.ceil(C/B)
an = math.ceil(A/D)

if tn <= an:
    print("Yes")
else:
    print("No")

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):
from sys import stdin
import math

A, B, C, D = list(map(int, input().split()))
attacks_till_a_win = math.ceil(C / B)
if D * (attacks_till_a_win - 1) < A:
    print('Yes')
else:
    print('No')

Solution (Python):
(a, b, c, d)=[int(x) for x in input().split()]
t=0
while a>0 and c>0:
  if t % 2:
    a-=d
  else:
    c-=b
  t+=1
print('Yes' if a > 0 else 'No')

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

aoki_out = math.ceil(C/B)
taka_out = math.ceil(A/D)

if(aoki_out <= taka_out):
  print('Yes')
else:
  print('No')

Solution (Python):


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

tak = (a+d-1)//d
aok = (c+b-1)//b

if tak>=aok:
    print('Yes')
else:
    print('No')

Solution (Python):

MOD = 10 ** 9 + 7

def main():
    for _ in inputt(1):
        a, b, c, d = inputi()
        if ceil(c / b) <= ceil(a / d):
            print("Yes")
        else:
            print("No")








from math import *
from heapq import *
from itertools import *
from functools import reduce, lru_cache, partial
from collections import Counter, defaultdict
import re, copy, operator, cmath
import sys, io, os, builtins
sys.setrecursionlimit(1000)





BUFSIZE = 8192
class FastIO(io.IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = io.BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(io.IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
    if args:
        sys.stdout.write(args[0])
        split = kwargs.pop("split", " ")
        for arg in args[1:]:
            sys.stdout.write(split)
            sys.stdout.write(arg)
    sys.stdout.write(kwargs.pop("end", "\n"))
def debug(*args, **kwargs):
    print("debug", *args, **kwargs)
    sys.stdout.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip()
inputt = lambda t = 0: range(t) if t else range(int(input()))
inputs = lambda: input().split()
inputi = lambda: map(int, inputs())
inputl = lambda t = 0, k = inputi: map(list, (k() for _ in range(t))) if t else list(k())





def len(a):
    if isinstance(a, range):
        return -((a.start - a.stop) // a.step)
    return builtins.len(a)
def bisect_left(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if key(a[mid]) < x: lo = mid + 1
        else: hi = mid
    return lo
def bisect_right(a, x, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    while lo < hi:
        mid = (lo + hi) // 2
        if x < key(a[mid]): hi = mid
        else: lo = mid + 1
    return lo
def insort_left(a, x, key = None, lo = 0, hi = None):
    lo = bisect_left(a, x, key, lo, hi)
    a.insert(lo, x)
def insort_right(a, x, key = None, lo = 0, hi = None):
    lo = bisect_right(a, x, key, lo, hi)
    a.insert(lo, x)
do_nothing = lambda x: x
bisect = bisect_right
insort = insort_right
def index(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    if key == None: key = do_nothing
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi and key(a[i]) == x: return a[i]
    if default != None: return default
    raise ValueError
def find_lt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_le(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo < i <= hi: return a[i - 1]
    if default != None: return default
    raise ValueError
def find_gt(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_right(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError
def find_ge(a, x, default = None, key = None, lo = 0, hi = None):
    if lo < 0: lo = 0
    if hi == None: hi = len(a)
    i = bisect_left(a, x, key, lo, hi)
    if lo <= i < hi: return a[i]
    if default != None: return default
    raise ValueError






class Tree:
    def __init__(n):
        self._n = n
        self._conn = [[] for _ in range(n)]
        self._list = [0] * n
    def connect(a, b):
        pass






class Sieve:
    def __init__(self):
        self._n = 6
        self._list = [2, 3, 5, 7, 11, 13]
    def extend(self, n):
        pass


sieve = Sieve()
def isprime(n):
    pass
def prime(n):
    pass
def factorint(n):
    factordict = defaultdict(int)
    for i in sieve:
        if n <= i * i:
            break
        while not n % i:
            factordict[i] += 1
            n //= i
    if n != 1:
        factordict[n] += 1
    return factordict





if __name__ == "__main__":
    main()

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):
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())
count=0
while (a>0) and (c>0):
    if count%2==0:
        c-=b
    else:
        a-=d
    count+=1

if  count%2==1:
    print("Yes")
else:
    print("No")

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


if __name__ == "__main__":
    main()

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

while a > 0 or c > 0:
  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())
tAtkN = ceil(c/b)
aAtkN = ceil(a/d)
if aAtkN < tAtkN:
    print("No")
else:
    print("Yes")

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

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

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

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):
import sys
input = sys.stdin.readline
def main():
    a,b,c,d = map(int,input().split())
    flg = 0
    while a > 0 and c > 0:
        if flg:a -= d;flg = 0
        else:c -= b;flg = 1
    if flg:print('Yes')
    else:print('No')
if __name__ == "__main__":
    main()

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):
T_hp, T_atk, A_hp, A_atk = tuple(map(int, input().split()))
while(True):
    A_hp -= T_atk
    if A_hp <= 0:
        print("Yes")
        break
    T_hp -= A_atk
    if T_hp <= 0:
        print("No")
        break

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

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

Solution (Python):
import math

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

t_attack = math.ceil(c/b)
a_attack = math.ceil(a/d)

if t_attack <= a_attack:
    print("Yes")
else:
    print("No")

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

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

Solution (Python):
import math
a, b, c, d = [int(i) for i in input().split()]
if math.ceil(c / b) <= math.ceil(a / d):
    print("Yes")
else:
    print("No")

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

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

Solution (Python):
from __future__ import print_function

import sys
sys.setrecursionlimit(500000)

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction

import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


















def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


def main():
    Al,Aa,Bl,Ba = map(int,input().strip().split())
    while True:
        Bl -= Aa
        if Bl<=0:
            print("Yes")
            return
        Al -= Ba
        if Al <= 0:
            print("No")
            return

if __name__ == '__main__':
    main()

Solution (Python):
ah,aa,bh,ba=list(map(int,input().split()))
while True:
  bh-=aa
  ah-=ba
  if bh<=0:
    print("Yes")
    break
  elif ah<=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):
A,B,C,D = map(int,input().split())
x = (C - 1)//B + 1
y = (A - 1)//D + 1
if x <= y:
    print("Yes")
else:
    print("No")

Solution (Python):
import math
a,b,c,d=map(int, input().split())
N=math.ceil(c/b)
if a-(N-1)*d>0:
  print('Yes')
else:
  print('No')

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
a,b,c,d = [int(i) for i in 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())

x=-(-A//D)
y=-(-C//B)

if x>=y:
    print('Yes')
else:
    print('No')

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

n = c//b
m = a//d

if c%b != 0:
    n += 1

if a%d != 0:
    m += 1

if n <= m:
    print("Yes")
else:
    print("No")

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

for i in range(100):
    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 or c <= 0:
        break

    c -= b
    if c <= 0:
        break
    a -= d


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

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



tkhs_cnt = ceil(C/B)
aok_cnt = ceil(A/D)
ans = "Yes" if aok_cnt >= tkhs_cnt else "No"
print(ans)

Solution (Python):

a,b,c,d=map(int,input().split())
for i in range(300):

  if i%2==0:
    c-=b
  else:
    a-=d
  if a<=0:
    print("No")
    exit(0)
  elif c<=0:
    print("Yes")
    exit(0)

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

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

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

if a%d == 0:
    tcnt = a//d
else:
    tcnt = a//d + 1

if c%b == 0:
    acnt = c//b
else:
    acnt = c//b + 1
    

if tcnt >= acnt:
    print('Yes')
else:
    print('No')

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
 
def main():
    a, b, c, d = map(int, input().split())
    while 1:
        c -= b
        if c <= 0:
            break
        a -= d
        if a <= 0:
            break
    if a <= 0:
        print('No')
    else:
        print('Yes')
if __name__ == '__main__':
    main()

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

i = 0
while True:
    if i % 2 == 0:
        C -= B
    else:
        A -= D

    if A <= 0:
        print("No")
        break
    if C <= 0:
        print("Yes")
        break
    i += 1

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

flag = True

while 1:
    if flag:
        c-=b
    else:
        a-=d
    if c<=0:
        print("Yes")
        exit()
    if a<=0:
        print("No")
        exit()
    flag = not flag

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 = list(map(int, input().split()))
c1 = -(-c//b)
c2 = -(-a//d)

if c1 <= c2:
    print('Yes')

else:
    print('No')

Solution (Python):

def resolve():
    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

if __name__ == "__main__":
    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=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')
        break
    A -= D
    if (A <= 0):
        print('No')
        break

Solution (Python):
A, B, C, D = map(int, input().split())
turn = 0
while (A > 0 and C > 0):
    if turn == 0:
        C = C - B
        turn = 1
    else:
        A = A - D
        turn = 0

if A > C:
    print("Yes")
else:
    print("No")

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

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:
    print('No')
elif c <= 0:
    print('Yes')

Solution (Python):
import math
import collections


def main():
    a, b, c, d = input_list()
    while True:
        c -= b
        if c <= 0:
            print('Yes')
            exit(0)
        a -= d
        if a <= 0:
            print('No')
            exit(0)


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


def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))


if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline

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

t = C // B if not C % B else C // B + 1
a = A // D if not A % D else A // D + 1

if t > a:
    print('No')
else:
    print('Yes')

Solution (Python):
l = input().split()
th = int(l[0])
ta = int(l[1])
ah = int(l[2])
aa = int(l[3])
win = False

while True:
	ah -= ta
	if ah <= 0:
		win = True
		break
	th -= aa
	if th <= 0:
		break

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

Solution (Python):
import sys
input = sys.stdin.readline

a, b, c, d = map(int, input().replace("\n","").split())

takahashihp = a
aokihp = c

while True:
    aokihp -= b
    if aokihp < 1:
        print("Yes")
        break
    takahashihp -= d
    if takahashihp < 1:
        print("No")
        break

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


if __name__ == "__main__":
    main()

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

from math import ceil

def check(A,B,C,D):
    if ceil(C/B)<=ceil(A/D):
        return True
    return False
if check(A,B,C,D):
    print('Yes')
else:
    print('No')

Solution (Python):
a,b,c,d = map(int,input().split())
for i in range(10**4):
    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())
import math
x=math.ceil(c/b)
y=math.ceil(a/d)
if x<=y:
    print("Yes")
else:
    print("No")

Solution (Python):
import collections
import sys
import numpy as np
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
MOD = 10**9+7
import itertools
import math

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

Solution (Python):
A,B,C,D=[int(x) for x in input().rstrip().split()]
import sys

flag=1
while(flag==1):
  if C!=0:
    C-=B
    if C<=0:
      print("Yes")
      sys.exit()

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

Solution (Python):
s=input().rstrip().split(' ')
th=int(s[0])
tss=int(s[1])
ah=int(s[2])
ass=int(s[3])
I=0;
while(1):
    if ah>0 and th>0:
        if I%2==0:
            I+=1;
            ah-=tss;
        else:
            th-=ass
            I+=1;
    else:
        break;
if I%2==0:
    print("No")
else:
    print("Yes")

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):
import sys
A, B, C, D = map(int, sys.stdin.readline().split())
T = 0
O = 0
while C > 0:
    C = C - B
    T += 1

while A > 0:
    A = A - D
    O += 1

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

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

turn = 0
while a > 0 and c > 0:
    if turn == 0:
        c -= b
    else:
        a -= d
    turn = (turn + 1) % 2

if a > 0:
    print("Yes")
else:
    print("No")

Solution (Python):
import math
T_hp, T_att, A_hp, A_att = map(int, input().split())

T_tae = math.ceil(T_hp/A_att)

A_tae = math.ceil(A_hp/T_att)

if T_tae >= A_tae: print("Yes")
else: print("No")

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

abc164_b()

Solution (Python):
a_HP, a_AT, b_HP, b_AT = map(int, input().split())

while True:
    b_HP -= a_AT
    if b_HP <= 0:
        print('Yes')
        break
    
    a_HP -= b_AT
    if a_HP <= 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('No')
else:
    print('Yes')

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

Solution (Python):
def q2():
    t_hp, t_atk, a_hp, a_atk = [int(i) for i in input().split(" ")]

    while True:
        a_hp -= t_atk
        if a_hp <= 0:
            print('Yes')
            return
        
        t_hp -= a_atk
        if t_hp <= 0:
            print('No')
            return
        

q2()

Solution (Python):
import sys
input = sys.stdin.readline


def log(*args):
    print(*args, file=sys.stderr)


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

for i in range(1000):
    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(1000):
    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:
        break
    a -= d
    if a <= 0:
        break
print('Yes' if c <= 0 else 'No')

Solution (Python):
from sys import setrecursionlimit, exit
setrecursionlimit(1000000000)

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

main()

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

for i in range(100):
    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_win=True
while True:
    c-=b
    if c<=0:
        takahashi_win=True
        break
    a-=d
    if a<=0:
        takahashi_win=False
        break


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

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


MOD = 10**9
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

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

t = 0
a = 0
if C%B==0: t = C // B
else: t = C // B + 1

if A%D==0: a = A // D
else: a = A // D + 1

if t > a: print('No')
else: print('Yes')

Solution (Python):
import math

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

Solution (Python):
from sys import stdin

[A, B, C, D]  = map(int, stdin.readline().rstrip().split())

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

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

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

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

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

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

Solution (Python):
import sys
import math
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
Yes = lambda boolean: print('Yes') if boolean else print('No')
YES = lambda boolean: print('YES') if boolean else print('NO')
aint = lambda: int(input())
ints = lambda: list(map(int, input().split()))
is_even = lambda x: True if x%2==0 else False
 
a,b,c,d = ints()
Yes(math.ceil(a/d)>=math.ceil(c/b))

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

Solution (Python):
A,B,C,D = (int(x) for x in input().split())
while(C > 0 and A > 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):
from math import ceil

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

if ceil(c/b) <= ceil(a/d):
    print('Yes')

else:
    print('No')

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

Solution (Python):
A,B,C,D=[int(i) for i in input().split()]
n = 1
while True:
    if n:
        C -= B
        if C < 1:
            print("Yes")
            exit()
    else:
        A-=D
        if A < 1:
            print("No")
            exit()
    n ^= 1

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

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

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

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

for i in range(10**9):
    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(A > 0):
    C = C-B
    if C <= 0:
        break
    A = A-D
print("Yes" if C <= 0 else "No")

Solution (Python):
a,b,c,d=map(int,input().split())
taka=0
ao=0
while a>0:
  a-=d
  taka+=1
while c>0:
  c-=b
  ao+=1
if taka>=ao:
  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')
        exit()

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

Solution (Python):
a,b,c,d=map(int, input().split())
taka=True
while a>0 and c>0:
    if taka:
        c-=b
    else:
        a-=d
    taka = not taka
if taka:
    print("No")
else:
    print("Yes")

Solution (Python):

A, B, C, D = [int(str) for str in input().strip().split()]

print('Yes' if (C - 1) // B <= (A - 1) // D else 'No')