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

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

taka=C/B
ao=A/D

if taka<=math.ceil(ao):
    print("Yes")
    
else:
    print("No")

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

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

Solution (Python):
import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            a,b,c=(inp+[1])[:3]
            org_inp.append(inp)
        else:
            index=0
            a,b,c=(list(ls[i])+[1])[:3]
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[1]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[1]+[mp_def[j] for j in s]+[1]
    mp+=[1]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase

input=lambda: sys.stdin.readline().rstrip()

class Comb:
    def __init__(self,n,mo=10**9+7):
        self.fac=[0]*(n+1)
        self.inv=[1]*(n+1)
        self.fac[0]=1
        self.fact(n)
        for i in range(1,n+1):
            self.fac[i]=i*self.fac[i-1]%mo
            self.inv[n]*=i
            self.inv[n]%=mo
        self.inv[n]=pow(self.inv[n],mo-2,mo)
        for i in range(1,n):
            self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
        return
    
    def fact(self,n):
        return self.fac[n]
        
    def invf(self,n):
        return self.inv[n]

    def comb(self,x,y):
        if y<0 or y>x:
            return 0
        return self.fac[x]*self.inv[x-y]*self.inv[y]%mo

show_flg=False
show_flg=True








class SegTree:

    def __init__(self,n,init_ls=None,init_val=0,function=lambda a,b:a+b,ide=0):
        self.n=n
        self.ide_ele=ide_ele=ide
        self.num=num=2**(n-1).bit_length()
        self.seg=seg=[self.ide_ele]*2*self.num
        self.lazy=lazy=[self.ide_ele]*2*self.num
        self.segfun=segfun=function
        
        if init_ls==None:
            for i in range(n):
                self.seg[i+self.num-1]=init_val
        else:
            for i in range(n):
                self.seg[i+self.num-1]=init_ls[i]
        
        for i in range(self.num-2,-1,-1):
            self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
    
    def update(self,k,x):
        k += self.num-1
        self.seg[k] = x
        while k:
            k = (k-1)//2
            self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
        
    def evaluate(k,l,r): 
        if lazy[k]!=0:
            node[k]+=lazy[k]
            if(r-l>1):
                lazy[2*k+1]+=lazy[k]//2
                lazy[2*k+2]+=lazy[k]//2

        lazy[k]=0
        
    def query(self,p,q):
        if q<=p:
            return self.ide_ele
        p += self.num-1
        q += self.num-2
        res=self.ide_ele
        while q-p>1:
            if p&1 == 0:
                res = self.segfun(res,self.seg[p])
            if q&1 == 1:
                res = self.segfun(res,self.seg[q])
                q -= 1
            p = p//2
            q = (q-1)//2
        if p == q:
            res = self.segfun(res,self.seg[p])
        else:
            res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
        return res
    
    def find_min_index(self,p,q,m):
        if q<=p:
            return self.ide_ele
        p += self.num-1
        q += self.num-2
        res=self.ide_ele
        while q-p>1:
            if p&1 == 0:
                res = self.segfun(res,self.seg[p])
            if q&1 == 1:
                res = self.segfun(res,self.seg[q])
                q -= 1
            p >>= 1
            q = (q-1)//2
        if p == q:
            res = self.segfun(res,self.seg[p])
        else:
            res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
        return res


    def __str__(self):
        
        rt=self.seg[self.num-1:self.num-1+self.n]
        return str(rt)

class Tree:
    def __init__(self,inp_size=None,init=True):
        if init:
            self.stdin(inp_size)
        return

    def stdin(self,inp_size=None):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1)
        return
    
    def listin(self,ls):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls)
        return

    def __str__(self):
        return  str(self.edges)

    def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append(x)
        v=[-1]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==-1:
                    q.append(nb)
                    v[nb]=func(v[c],nb,d)
        return v

    def EulerTour(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append((-1,x))
        v=[None]*self.size
        v[x]=root_v
        et=[]
        while q:
            cb,ce=q.pop()
            et.append(ce)
            for nb,d in self.edges[ce]:
                if v[nb]==None:
                    q.append((nb,ce))
                    q.append((ce,nb))
                    v[nb]=func(v[ce],nb,d)
        vid=[[-1,-1]for i in range(self.size)]
        for i,j in enumerate(et):
            if vid[j][0]==-1:
                vid[j][0]=i
            else:
                vid[j][1]=i
        return v,et,vid
    
    def LCA_init(self,depth,et):
        self.st=SegTree(self.size*2-1,func=min,ide=inf)
        for i,j in enumerate(et):
            self.st.update(i,j)
        self.LCA_init_stat==True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            depth,et,vid=self.EulerTour(root)
            self.LCA_init(depth,et)
        return self.st.query(x,y+1)

def dijkstra(edge,st):
    
    
    n=len(edge)
    d=[(0 if st==i else inf) for i in range(n)]
    prev=[0]*n
    q=[(j,i) for i,j in enumerate(d)]
    heapify(q)
    
    
    while q:
        dist,cur=heappop(q)
        for dst,dist in edge[cur]:
            alt=d[cur]+dist
            if alt<d[dst]:
                d[dst]=alt
                prev[dst]=cur
                heappush(q,(alt,dst))
    return d,prev


ans=0

a,b,c,d=LI()
while True:
    c-=b
    if c<=0:
        k=0
        break
    a-=d
    if a<=0:
        k=1
        break
    

print(Yn[k])

Solution (Python):
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


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


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor



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

Solution (Python):
import math

def main():
  a, b, c, d = map(int, input().split())
  
  n = c/b
  n_ = math.ceil(n)
  m = a/d
  m_ = math.ceil(m)
  
  if n_ <= m_:
    print('Yes')
  else:
    print('No')

main()

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

n = 0

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

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

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

Solution (Python):
X = list(map(int,input().split()))

A = X[0]
B = X[1]
C = X[2]
D = X[3]


n = 0
while C>0:
  C = C-B
  n += 1

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

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

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

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):
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 c%b>0:
    x=c//b+1
else:
    x=c//b

if a%d>0:
    y=a//d+1
else:
    y=a//d
print('Yes' if x<=y else 'No')

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

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

Solution (Python):
li=list(map(int,input().split()))
a=li[0]
b=li[1]
c=li[2]
d=li[3]
while True:
    c-=b
    if c>0:
        a-=d
        if a>0:
            continue
        else:
            print('No')
            break
    else:
        print('Yes')
        break

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


while A != 0 or C !=0:
    C = C - B
    if C <= 0:
        break
    A = A - D
    if A <= 0:
        break

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

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

n = 1

while C > n*B and A > n*D :
    n += 1

if C <= n*B :
    print("Yes")
else : print("No")

Solution (Python):
import sys
from math import factorial
from collections import Counter
from fractions import Fraction
import heapq, bisect, fractions
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
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()))
MOD = 10**9 + 7


a, b, c, d = MAP()

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 = False
while a > 0 and c > 0:
    if turn:
        a -= d
    else:
        c -= b
    turn = not turn 
if a <= 0:
    print('No')
else:
    print('Yes')

Solution (Python):
import sys
a, b, c, d = map(int, input().split())
times = (a//d) + 1
if  d >= a :
    if b >= c :
        print("Yes")
        sys.exit()
    else :
        print("No")
        sys.exit()
if a%d == 0 :
    times -= 1
if times * b >= c :
    print("Yes")
else :
    print("No")

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

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

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

if (int(A) - 1)//(int(D)) >= (int(C) - 1)//(int(B)):
    print('Yes')

else:
    print('No')

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

if c%b != 0:
    cb = c//b+1
else:
    cb = c//b
if a%d != 0:
    ad = a//d+1
else:
    ad = a//d

if cb <= ad:
    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):
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):
a,b,c,d = map(int,input().split())
r1 = a//d
if a%d==0:
  pass
else:
  r1 += 1
r2 = c//b
if c%b==0:
  pass
else:
  r2 += 1
if r1>=r2:
  print('Yes')
else:
  print('No')

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

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

if a%d == 0:
    tao -=1

if c%b == 0:
    ttk -=1


if tao >= ttk:
    print("Yes")
else:
    print("No")

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

Solution (Python):



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

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

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

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

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

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

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

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

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

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

Solution (Python):
a=list(map(int,input().split()))
for i in range(1,101):
    if a[2]-i*a[1]<=0:
        print("Yes")
        break
    elif a[0]-i*a[3]<=0:
        print("No")
        break

Solution (Python):
import math

line = input().split()
a = int(line[0])
b = int(line[1])
c = int(line[2])
d = int(line[3])

t = math.ceil(c / b)
s = math.ceil(a / d)

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

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

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


def win_takahashi(A, B, C, D):

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

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

if win_takahashi(A, B, C, D):
	print('Yes')
else:
	print('No')

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

Solution (Python):
th,ta,ah,aa = map(int,input().split())
cnt_t = 0
cnt_a = 0

for i in range(100):
    ah = ah - ta
    if ah <= 0:
        print("Yes")
        break
    else:
        th = th - aa
        if th <= 0:
            print("No")
            break

Solution (Python):

import sys, re
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
from heapq import heappush, heappop, heapify, nlargest, nsmallest
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def sortListWithIndex(listOfTuples, idx):   return (sorted(listOfTuples, key=lambda x: x[idx]))
def sortDictWithVal(passedDic):
    temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
    toret = {}
    for tup in temp:
        toret[tup[0]] = tup[1]
    return toret
def sortDictWithKey(passedDic):
    return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

a,b,c,d = MAP()

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

print(winner)

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

Solution (Python):
def ceiling(a, b):
    return int((a + b - 1) / b)


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

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

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

Solution (Python):









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

if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys

inputLine=input()
A=int(inputLine.split(" ")[0])
B=int(inputLine.split(" ")[1])
C=int(inputLine.split(" ")[2])
D=int(inputLine.split(" ")[3])

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

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

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

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

takeshi_turn = True
while a > 0 and c > 0:
	if takeshi_turn:
		c -= b
		takeshi_turn = False
	else:
		a -= d
		takeshi_turn = True

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

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

Solution (Python):
[a,b,c,d]=list(map(int,input().split()))
ans="No"
chokudai=c//b
if c%b!=0:
    chokudai+=1
aoki=a//d
if a%d!=0:
    aoki+=1
if chokudai<=aoki:
    ans="Yes"
print(ans)

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):
a,b,c,d = map(int,input().split())
for v in range(1000):
    if c - v*b <= 0:
        ans = "Yes"
        break
    if a - v*d <= 0:
        ans = "No"
        break
print(ans)

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

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

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

Solution (Python):
list=input().split(" ")
T_phy=int(list[0])
T_atk=int(list[1])
A_phy=int(list[2])
A_atk=int(list[3])

T_defeat_turn=int(T_phy/A_atk)
if T_phy%A_atk!=0:
    T_defeat_turn+=1
A_defeat_turn=int(A_phy/T_atk)
if A_phy%T_atk!=0:
    A_defeat_turn+=1

if A_defeat_turn>T_defeat_turn:
    print("No")
else:
    print("Yes")

Solution (Python):
def resolve():
  A, B, C, D = map(int, input().split(" "))
  Takahashi = {
    "attack": B,
    "HP": A
  }

  Aoki = {
    "attack": D,
    "HP": C
  }
  
  winner = True
  while True:
    Aoki["HP"] -= Takahashi["attack"]
    if (Aoki["HP"] <= 0):
      winner = True
      break

    Takahashi["HP"] -= Aoki["attack"]
    if (Takahashi["HP"] <= 0):
      winner = False
      break

  print("Yes" if winner else "No")

if __name__ == "__main__":
    resolve()

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


isWin = True

while(True):
    c -= b
    if(c <= 0):
        break
    a -= d
    if(a <= 0):
        isWin = False
        break
    

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

Solution (Python):
import math
a,b,c,d=map(int,input().split())
a1,a2=0,0
if(c%b==0):
	a1=math.floor(c/b)
else:
	a1=math.floor(c/b)+1	
if(a%d==0):
	a2=math.floor(a/d)
else:
	a2=math.floor(a/d)+1
	
if(a1>a2):
	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):
a, b, c, d = map(int, input().split())

while True:

    if c - b <= 0:
        print("Yes")
        break
    else:
        c = c - b

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

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

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())
print('No' if (c - 1) // b > (a - 1) // d else '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().strip().split())

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

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

Takahashi = A
Aoki = C

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

    Takahashi = Takahashi - D
    if Takahashi <= 0:
        break

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

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

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

is_true = True
if taka < ao:
    is_true = True
elif taka > ao:
    is_true = False
else:
    if b > d:
        is_true = False

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

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

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

print(ans)
"""
print("Yes" if   -(-c//b) <=-(-a//d)  else "No")

Solution (Python):
import sys

YES = "Yes"  
NO = "No"  


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

    while True:
        C = C - B

        if C <= 0:
            print(YES)
            break

        A = A - D

        if A <= 0:
            print(NO)
            break

    return

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

if __name__ == '__main__':
    main()

Solution (Python):
a=list(map(int,input().split()))
while a[0]>0 and a[2]>0:
    a[2]=a[2]-a[1]
    if a[2]<=0:
        print('Yes')
        break
    a[0]=a[0]-a[3]
    if a[0]<=0:
        print('No')
        break

Solution (Python):
a,b,c,d = input().strip().split()
a,b,c,d = [int(a),int(b),int(c),int(d)]
while a>0 and c>0:
    a = a-d
    c = c-b
    if (a<=0 and c<=0) or (a>0 and c<=0):
        print("Yes")
    if a<=0 and c>0:
        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):
k = list(map(int, input().split() ) )
t = 1
while k[0] > 0 and k[2] > 0:
  if t == 1:
    k[2] -= k[1]
    t=2
  else:
    k[0] -= k[3]
    t=1
if t==2:
  print("Yes")
else:
  print("No")

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

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

def battle(player):
    global A
    global C

    if player == 1:
        C = C - B
    else:
        A = A - D

    return None

def main():
    while True:
       battle(1) 
       if C <= 0:
           print("Yes")
           break

       battle(2)
       if A <= 0:
           print("No")
           break

    return None

main()

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

taka = math.ceil(A/D)
aoki = math.ceil(C/B)

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

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

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

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

x = c/b
y = a/d

if x > int(x):
    x+=1
    x=int(x)
if y > int(y):
    y+=1
    y=int(y)

if x <= y:
    print("Yes")
else:
    print("No")

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

t_kai = (A // D)
if A % D != 0:
    t_kai += 1

a_kai = (C // B)
if C % B != 0:
    a_kai += 1

if t_kai >= a_kai:
    print("Yes")
else:
    print("No")

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

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

print("Yes" if t_h>a_h else "No")

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):
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd

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

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())
count = 0
while A > 0 and C > 0:
    if count % 2 == 0:
        C -= B
    else:
        A -= D
    count += 1

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

Solution (Python):
import math

a,b,c,d =map(float,input().split())
if c <= b*(math.ceil(a/d)):
  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):
a, b, c, d= map(int, input().split())
while(True):
  c = c - b
  if c <= 0 and a > 0:
    print("Yes")
    break
  a = a - d
  if c > 0 and a <= 0:
    print("No")
    break

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

def judge(A,B,C,D):
    while(True):
        C = C-B
        A = A - D
        if C<=0:
            return 1
            break
        elif A<=0:
            return 0
            break
if judge(A,B,C,D)==1:
    print("Yes")
else:
    print("No")

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