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 math
import keyword

def Next(): return input()
def NextInt(): return int(Next())
def NextInts(): return map(int,input().split())
def Nexts(): return map(str,input().split())
def NextIntList(): return list(map(int,input().split()))
def RowInts(n): return [input() for i in range(n)]

a,b,c,d = NextInts()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]






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

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

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

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

if aoki<taka:
    print("No")
else:
    print("Yes")

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

Solution (Python):
import numpy as np
import math

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

Solution (Python):
A, B, C, D = map(int, input().split())
a, t = -(-A//D), -(-C//B)
if a < t:
    print("No")
else:
    print("Yes")

Solution (Python):
def main():
    A, B, C, D = [int(x) for x in 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):

import sys
input= lambda: sys.stdin.readline().rstrip()
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))

def resolve():
    A,B,C,D=pin()
    turn=0
    while(1):
        if turn%2 ==0:
            C-=B
        else:
            A-=D
        if C<1 or A<1:
            
            print((["No","Yes"][turn%2==0]))
            break
        turn+=1
        

resolve()

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

turn = 0
while A >= 1 and C >= 1:
    if turn % 2 == 0:
        C -= B
    else:
        A -= D
    turn += 1
if A <= 0:
    print("No")
else:
    print("Yes")

Solution (Python):

import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline

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

taka = -(-a//d)
ao = -(-c//b)


if taka < ao:
    print('No')
else:
    print('Yes')

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 a<=0:
    print('No')
else:
    print('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
print('Yes' if a>0 else '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):
a, b, c, d = map(int, input().split())

T = (a + d - 1) // d
A = (c + b - 1) // b

print("Yes" if T >= A 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):
a, b, c, d = map(int, input().split())
x = (a + d - 1) // d
y = (c + b - 1) // b
print('Yes' if x >= y else '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):
import sys
input = lambda: sys.stdin.readline().rstrip()
import math

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


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


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

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

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

print("Yes") if taka <= ao else print("No")

Solution (Python):
import sys
import math

input = sys.stdin.readline

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

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

Solution (Python):
from sys import stdin
from sys import setrecursionlimit
import math
setrecursionlimit(10 ** 7)

a,b,c,d = map(int,stdin.readline().rstrip().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 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())

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

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

i = 0
while True:
    if 0 == i % 2:
        c -= b
    else:
        a -= d

    if a <= 0:
        print("No")
        break
    elif c <= 0:
        print("Yes")
        break
    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):
import sys
sys.setrecursionlimit(1000000000)
import math
from math import gcd
def lcm(a, b): return a * b // gcd(a, b)
from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint
ii = lambda: int(input())
mis = lambda: map(int, input().split())
lmis = lambda: list(mis())
INF = float('inf')
N1097 = 10**9 + 7

def meg(f, ok, ng):
    while abs(ok-ng)>1:
        mid = (ok+ng)//2
        if f(mid):
            ok=mid
        else:
            ng=mid
    return ok

def get_inv(n, modp):
    return pow(n, modp-2, modp)

def factorials_list(n, modp):    
    fs = [1]
    for i in range(1, n+1):
        fs.append(fs[-1] * i % modp)
    return fs

def invs_list(n, fs, modp):     
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1-1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs

def comb(n, k, modp):
    num = 1
    for i in range(n, n-k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k+1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp

def comb_from_list(n, k, modp, fs, invs):   
    return fs[n] * invs[n-k] * invs[k] % modp



class UnionFindEx:
    def __init__(self, size):
        
        self.roots = [-1] * size
    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:   
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r
    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]
    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]    
        self.roots[r2] = r1
        return True

Yes = 'Yes'
No = 'No'


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




main()

Solution (Python):
import math

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

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

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

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

x=-(-c//b)
y=-(-a//d)

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

Solution (Python):
import sys
import math


def input():
    return sys.stdin.readline().strip()


def main():
    A, B, C, D = map(int, input().split())
    T = math.ceil(C / B)
    Aoki = math.ceil(A / D)

    if Aoki + 1 <= T:
        print("No")
    else:
        print("Yes")


if __name__ == "__main__":
    main()

Solution (Python):
a,b,c,d=map(int,input().split())
for i in range(100):
    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()))
X = A//D
if A//D != A/D:
    X+=1
Y = C//B
if C//B != C/B:
    Y+=1

if Y<=X:
    print("Yes")
else:
    print("No")

Solution (Python):


import sys
import math
import collections
import itertools
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def lcm(x, y) : return (x * y) // math.gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")

A, B, C, D = LI()

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

    if A <= 0:
        flag = False
        break
    elif C <= 0:
        flag = True
        break

YesNo(flag)

Solution (Python):
n,n_a,m,m_a=list(map(int,input().split()))
while(True):
    m-=n_a
    if m<=0:
        print("Yes")
        break
    n-=m_a
    if n<=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())
t=-(-c//b)
a=-(-a//d)
if t<=a:
    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())
for i in range(10000):
    if i%2==0:
        C-=B
        if C<=0:
            print("Yes")
            exit()
    else:
        A-=D
        if A<=0:
            print("No")
            exit()

Solution (Python):
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import time
import math
def gcd(a,b):
    if(a%b==0):return(b)
    return (gcd(b,a%b))
A,B,C,D=map(int,input().split())
if C//B+bool(C%B)*1<=A//D+bool(A%D)*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')
        exit()
    A -= D
    if A <= 0:
        print('No')
        exit()

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

taka = a
aoki = c

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

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

takahashi = c // b
if c % b != 0:
    takahashi += 1
aoki = a // d
if a % d != 0:
    aoki += 1

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

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

for i in range(10000000):
  c-=b
  if c<=0:
    print("Yes")
    exit()
  a-=d
  if a<=0:
    print("No")
    exit()

Solution (Python):
A, B, C, D = list(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):
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()

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


resolve()

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 = 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=map(int,input().split())
for n in range(300):
    if n%2==0:
        c-=b
        if c<=0:
            print('Yes')
            exit()
    else:
        a-=d
        if a<=0:
            print('No')
            exit()

Solution (Python):
t_hlth, t_atk, a_hlth, a_atk = [int(x) for x in input().split(' ')]

t_kill_turn = (a_hlth + t_atk - 1) // t_atk
a_kill_turn = (t_hlth + a_atk - 1) // a_atk

if t_kill_turn > a_kill_turn:
    print("No")
else:
    print("Yes")

Solution (Python):
A, B, C, D = map(int, input().split())
Ta = -(-C//B)
Ao = -(-A//D)
print('Yes' if Ta <= Ao else 'No')

Solution (Python):
import sys
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  
from math import gcd

A, B, C, D = read_ints()

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

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

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

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

e = 0

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

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

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

def s_in():
    return input()

def n_in():
    return int(input())

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

def print_l(l):
    print(' '.join(map(str, l)))

class Interval():
    def __init__(self, li):
        self.li = li
        self.n = len(li)
        self.sum_li = [li[0]]
        for i in range(1, self.n):
            self.sum_li.append(self.sum_li[i-1] + li[i])

    def sum(self, a, b=None):
        if b is None:
            return self.sum(0, a)

        res = self.sum_li[min(self.n-1, b-1)]
        if a > 0:
            res -= self.sum_li[a-1]
        return res

a,b,c,d = l_in()

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

count = 0
while A > 0 and C > 0:
    if count % 2 == 0:
        C -= B
    else:
        A -= D
        
    count += 1

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

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

Solution (Python):
import sys, math
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7

A, B, C, D = rl()

flag = True
while A > 0 and C > 0:
	if flag:
		C -= B
	else:
		A -= D
	flag = not flag
if A > 0:
	print('Yes')
else:
	print('No')

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

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

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

while(1):
    c-=b
    a-=d
    if c<=0:
        print("Yes")
        break
    elif 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):
A,B,C,D = map(int, input().split())

for i in range(max(A,C)):
    C = C - B
    if C <= 0:
        print("Yes")
        quit()

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

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

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

if C > 0:
    print('No')
else:
    print('Yes')

Solution (Python):
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue

Mod = 1000000007
  
def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))+1):
        if prime[i] == 1:
            for j in range(2*i,n+1):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n+1):
        if prime[i] == 1:
            res.append(i)
    return res

 
class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py
 
    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

def main():  
    a, b, c, d = 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()
if __name__ == "__main__":
    main()

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
A, B, C, D = map(int, input().split())
t = 0
while A > 0 and (C > 0):
  if t % 2: A -= D
  else: C -= B
  t += 1
if A > 0: 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):
from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import permutations,combinations
from collections import defaultdict,Counter
from bisect import bisect_left,bisect_right


from functools import reduce
from pprint import pprint

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

def mylistinput(n):
    return [ list(myinput()) for _ in range(n) ]

def mycol(data,col):
    return [ row[col] for row in data ]

def mysort(data,col,reverse_flag):
    data.sort(key=lambda x:x[col],reverse=reverse_flag)
    return data

def mymax(data):
    M = -1*float("inf")
    for i in range(len(data)):
        m = max(data[i])
        M = max(M,m)
    return M

def mymin(data):
    m = float("inf")
    for i in range(len(data)):
        M = min(data[i])
        m = min(m,M)
    return m

def myoutput(ls,space=True):
    if space:
        if len(ls)==0:
            print(" ")
        elif type(ls[0])==str:
            print(" ".join(ls))
        elif type(ls[0])==int:
            print(" ".join(map(str,ls)))
        else:
            print("Output Error")
    else:
        if len(ls)==0:
            print("")
        elif type(ls[0])==str:
            print("".join(ls))
        elif type(ls[0])==int:
            print("".join(map(str,ls)))
        else:
            print("Output Error")

a,b,c,d = myinput()

while True:
    
    c -= b
    if c<=0:
        print("Yes")
        exit()
    else:
        pass
    
    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()
    else:
        A-=D
    if A<=0:
        print("No")
        sys.exit()

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

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

Solution (Python):



def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    

    def dump(*args):
        sys.stderr.write(str(args))

    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 = 1 - turn
    if a > 0:
        print('Yes')
    else:
        print('No')


if __name__ == '__main__':
    main()

Solution (Python):
import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, ceil, gcd
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)


class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())


def dijkstra_heap(s, edge, n):
    
    d = [10**20] * n
    used = [True] * n 
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr


def lcm(x, y):
    return (x * y) // gcd(x, y)


def lcm_list(numbers):
    return reduce(lcm, numbers, 1)


def gcd_list(numbers):
    return reduce(gcd, numbers)


def is_prime(n):
    if n <= 1:
        return False
    p = 2
    while True:
        if p ** 2 > n:
            break
        if n % p == 0:
            return False
        p += 1
    return True



def eratosthenes(limit):
    A = [i for i in range(2, limit+1)]
    P = []

    while True:
        prime = min(A)
        
        if prime > sqrt(limit):
            break
            
        P.append(prime)
            
        i = 0
        while i < len(A):
            if A[i] % prime == 0:
                A.pop(i)
                continue
            i += 1
            
    for a in A:
        P.append(a)
            
    return P


def permutation_with_duplicates(L):

    if L == []:
        return [[]]

    else:
        ret = []

        
        S = sorted(set(L))

        for i in S:

            data = L[:]
            data.remove(i)

            for j in permutation_with_duplicates(data):
                ret.append([i] + j)

        return ret



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

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


taka = math.ceil(a / d)
ao = math.ceil(c / b)

if taka >= ao:
    print("Yes")
else:
    print("No")

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

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


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

Solution (Python):
import collections
import math
import operator as op
from functools import reduce
from collections import Counter
import numpy as np
import math
import bisect
import heapq

MOD = 1000000007


def get_inputs(cast_func=None):
    if cast_func is None:
        return input().split()
    else:
        return list(map(cast_func, input().split()))


def get_input(cast_func=None):
    if cast_func is None:
        return input()
    else:
        return cast_func(input())


def main():
    
    
    
    
    

    A, B, C, D = get_inputs(int)

    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



if __name__ == '__main__':
    main()

Solution (Python):
a,b,c,d = map(int, input().split())
ta = (a-1)//d + 1
ao = (c-1)//b + 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())

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(1000):
    C = C-B
    A = A-D
    if C <= 0:
        print('Yes')
        break
    if A <= 0:
        print('No')
        break

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

    A -= D
    if A<1:
        print('No')
        break

Solution (Python):
import math
a1, a2, b1, b2 = map(int, input().split())

c1 = math.ceil(a1/b2)
c2 = math.ceil(b1/a2)

if(c1>=c2):print("Yes")
else:print("No")