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



Sample input:
10 9 10 10


Sample output:
No

Submission status: Accepted

Solution code:
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={'#':1,'.':0}):
#h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
    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
#sys.setrecursionlimit(10**7)
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


## Segment Tree ##

## Initializer Template ##
# Range Sum:        sg=SegTree(n)
# Range Minimum:    sg=SegTree(n,inf,min,inf)

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
        #set_val
        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]
        #build
        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):
    # edge=[[(v_to,dist_to_v),...],[],...]
    # initialize: def: d=dist(st,i), prev=[previous vertex in minimum path], q[]
    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)
    
    # calc
    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])

Submission status: Accepted

Solution code:
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


# coordinates
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

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

else:
    print('No')

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

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

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

Submission status: Accepted

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

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

# B - Battle
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')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
# Template 1.0
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)

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
# coding: utf-8
# def debug(arg):
#     if __debug__:
#         pass
#     else:
#         import sys
#         print(arg, file=sys.stderr)

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
[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)

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

  Aoki = {
    "attack": D,
    "HP": C
  }
  # print("resolve", A, B, C, D)
  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()

Submission status: Accepted

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

#print(a,b,c,d)
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')

Submission status: Accepted

Solution code:
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
	# print(a1,a2)
if(a1>a2):
	print("No")
else:
	print("Yes")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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;

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
import sys

YES = "Yes"  # type: str
NO = "No"  # type: str


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))  # type: int
    B = int(next(tokens))  # type: int
    C = int(next(tokens))  # type: int
    D = int(next(tokens))  # type: int
    solve(A, B, C, D)

if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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")