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

Submission status: Accepted

Solution code:
# coding: utf-8

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)

Submission status: Accepted

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

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().split())
t=-(-c//b)
a=-(-a//d)
if t<=a:
    print("Yes")
else:
    print("No")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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
    # return [list(map(int, read().split())) for _ in range(H)] # 内包表記はpypyでは遅いため


MOD = 10**9 + 7
INF = 2**31  # 2147483648 > 10**9
# default import
from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  # , insort_left, insort_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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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
    else:
        A -= D
        
    count += 1

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

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:
#!/usr/bin/env python3

# N = int(input())
# S = input()

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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
#import sympy as syp(素因数分解とか)
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():  #startline-------------------------------------------
    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() #endline===============================================

Submission status: Accepted

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

Submission status: Accepted

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

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:
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 math import gcd,ceil,floor,factorial
# from fractions import gcd
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()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# ABC164b


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**6)
    # 再帰関数を使わない限りPypyで出すこと

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


if __name__ == '__main__':
    main()

Submission status: Accepted

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

# UnionFind
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):
    #始点sから各頂点への最短距離
    d = [10**20] * n
    used = [True] * n #True:未確定
    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

# 2数の最小公倍数
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


# limit以下の素数を列挙
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 = []

        # set（集合）型で重複を削除、ソート
        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")

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

Submission status: Accepted

Solution code:
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():
    # S, W = get_inputs(int)
    # if W >= S:
    #     print("unsafe")
    # else:
    #     print("safe")

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

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

        turn ^= 1



if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

c1 = math.ceil(a1/b2)
c2 = math.ceil(b1/a2)
#print(c1, c2)
if(c1>=c2):print("Yes")
else:print("No")

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10 ** 6)  # 再帰関数の再帰の深さを設定
to_index = lambda x: int(x) - 1  # 入力した数字に1を引いたものを返す
print_list_in_2D = lambda x: print(*x, sep="\n")  # リストの要素を改行を挟んで表示する関数

# 入力を整数に変換して受け取る
def input_int():
    return int(input())

def map_int_input():
    return map(int, input())

MII = map_int_input

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

def MII_to_index():
    return map(to_index, input())

def MII_split_to_index():
    return map(to_index, input().split())

# 入力全てを整数に変換したものの配列を受け取る
def list_int_inputs():
    return list(map(int, input()))

LII = list_int_inputs

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

# 2次元リスト化
def LII_2D(rows_number):
    return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number):
    return [LII_split() for _ in range(rows_number)]

A, B, C, D = MII_split()

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# B

import sys
# 再起回数上限変更
# sys.setrecursionlimit(1000000)

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

for i in range(100):
    C -= B
    if C <= 0:
        print('Yes')
        sys.exit()
    A -= D
    if A <= 0:
        print('No')
        sys.exit()

Submission status: Accepted

Solution code:
from math import ceil
a,b,c,d=map(int,input().split())
takahashi=ceil(c/b)
aoki=ceil(a/d)
if takahashi<=aoki:
    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:
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().rstrip().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:
H1, A1, H2, A2 = map(int, input().split())
while True:
    H2 -= A1
    if H2 <= 0:
        print("Yes")
        break
    H1 -= A2
    if H1 <= 0:
        print("No")
        break

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 26 20:56:50 2020

@author: Kanaru Sato
"""

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

takahashiturns = -1*((-1*c)//b)
aokiturns = -1*((-1*a)//d)

if takahashiturns <= aokiturns:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
a,b,c,d = [int(i) for i in 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().split())
print('No' if -(-c//b)>-(-a//d) else 'Yes')

Submission status: Accepted

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


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

Submission status: Accepted

Solution code:
A, B, C, D = list(map(int, input().split()))
while A > 0 and C > 0:
    C -= B
    if not C > 0:
        print('Yes')
        break
    A -= D
    if not A > 0:
        print('No')
        break

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:
A, B, C, D = map(int, input().split())
i = 0
while True:
    if i % 2 == 0:
        C -= B
        if C <= 0:
            print("Yes")
            exit()
    else:
        A -= D
        if A <= 0:
            print("No")
            exit()
    i += 1

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
# TAKA hp A atk B
# AOKI hp C atk D
# TAKA -> AOKI -> TAKA -> ...
mode = 0
cnt = 0
while True:
	mode ^= 1
	if mode == 0:
		a = a - d
		if a <= 0:
			print("No")
			break
	else:
		c = c - b
		if c <= 0:
			print("Yes")
			break

Submission status: Accepted

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

Submission status: Accepted

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

k=(a-1)//d
l=(c-1)//b
if k<l:
   print('No')
else:
   print("Yes")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
T_HP,T_ATK,A_HP,A_ATK = [int(i) for i in input().split()]
while 1:
    A_HP -= T_ATK
    if A_HP <1:
        print("Yes")
        break
    T_HP -= A_ATK
    if T_HP <1:
        print("No")
        break

Submission status: Accepted

Solution code:
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from heapq import heapify, heappop, heappush

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
 
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

A, B, C, D = MAP()

while 1:
    C -= B
    # print(C)
    if C <= 0:
        print("Yes")
        exit()
    A -= D
    # print(A)
    if A <= 0:
        print("No")
        exit()

Submission status: Accepted

Solution code:
a,b,c,d = [int(i) for i in 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 A >= 0 and C >= 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 = list(map(int, input().split()))


def ceil(a, b):
    return -(-a // b)


x = ceil(c, b)
y = ceil(a, d)
if x <= y:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *					# ll = deepcopy(l)
from heapq import *					# heappush(hp,x)
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize				# minn = -maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *				# pre = [0] + list(accumulate(l))
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''

'''

def solve(l):
	f = 1
	h1,s1,h2,s2 = l
	while(h1 > 0 and h2 > 0):
		h2 -= s1
		if(h2 <= 0):
			break
		h1 -= s2
	if(h1 <= 0):
		f = 0
	if(f):
		return 'Yes'
	else:
		return 'No'

l = list(map(int, stdin.readline().rstrip().split()))
ans = solve(l)
print(ans)

Submission status: Accepted

Solution code:
#b
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:
# -*- coding: utf-8 -*-
import numpy as np
from collections import deque
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()

Submission status: Accepted

Solution code:
a,b,c,d=map(int,input().split())
x=c//b+(c%b!=0)
y=a//d+(a%d!=0)
print('Yes' if x<=y else 'No')

Submission status: Accepted

Solution code:


th, ta, ah, aa = map(int, input().split())

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

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