Problem:


Score : 100 points

Problem Statement

Takahashi is meeting up with Aoki.

They have planned to meet at a place that is D meters away from Takahashi's house in T minutes from now.

Takahashi will leave his house now and go straight to the place at a speed of S meters per minute.

Will he arrive in time?

Constraints

1 \leq D \leq 10000

1 \leq T \leq 10000

1 \leq S \leq 10000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

D T S

Output

If Takahashi will reach the place in time, print Yes; otherwise, print No.

Sample Input 1

1000 15 80

Sample Output 1

Yes

It takes 12.5 minutes to go 1000 meters to the place at a speed of 80 meters per minute. They have planned to meet in 15 minutes so he will arrive in time.

Sample Input 2

2000 20 100

Sample Output 2

Yes

It takes 20 minutes to go 2000 meters to the place at a speed of 100 meters per minute. They have planned to meet in 20 minutes so he will arrive just on time.

Sample Input 3

10000 1 1

Sample Output 3

No

He will be late.



Sample input:
1000 15 80


Sample output:
Yes

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())

if d/s > t:
  print('No')
else:
  print('Yes')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if D / S <= T:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
A = list(map(float, input().split()))

if(A[0]/A[2] <= A[1]):
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())

if d>t*s:
  print('No')
else:
  print('Yes')

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split(" "))
if(D/S<=T):
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d,t,s= map(int,input().split(" "))
print("Yes" if t>=d*1.0/s else "No")

Submission status: Accepted

Solution code:
a,b,c=[int(a) for a in input().split()]
if b*c>=a:
  print ("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
actualTime=d/s
 
if actualTime<=t:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if t*s < d:
  print("No")
else:
  print("Yes")

Submission status: Accepted

Solution code:
D, T , S = map(int,input().split())
move = T * S
if move >= D:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
requestMap = list(map(float, input().split()))

D = requestMap[0]
T = requestMap[1]
S = requestMap[2]

dist = S * T

if dist >= D:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())

tmp = d/s

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

Submission status: Accepted

Solution code:
import sys

num_list = [int(i) for i in input().split()]

if num_list[0] / num_list[2] <= num_list[1]:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S=map(int, input().split())
if T-D/S>=0 :
  print('Yes')

else  :
  print('No')

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())

if D <= T*S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D,T,S = map(int, input().split())
ans = 'Yes' if D / S <= T else 'No'
print(ans)

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
if d/s<=t:print("Yes")
else:print("No")

Submission status: Accepted

Solution code:
D,T,S=list(map(int,input().split()))
if T*S>=D:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d, t, s= map(int,input().split())
if d/s <= t:
    print('Yes')
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())

if d <= t * s:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if D <= T*S:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
D, T, S = (int(x) for x in input().split())

if D <= T*S:
    print ("Yes")
else:
    print ("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if d > t * s:
  print("No")
else:
  print("Yes")

Submission status: Accepted

Solution code:
dts_s = input().split()
dts_i = [int(n) for n in dts_s]
if dts_i[0]/dts_i[1] > dts_i[2]:
  print("No")
else:
  print("Yes")

Submission status: Accepted

Solution code:
d, t, s = map(int,input().split(' '))
print('Yes' if d/s <= t else 'No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if D / S <= T:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

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

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if s*t<d:
  print('No')
else:
  print('Yes')

Submission status: Accepted

Solution code:
a = input().split()
D = int(a[0])
T = int(a[1])
S = int(a[2])

jikan = D / S

if(jikan > T):
  print("No")
else:
  print("Yes")

Submission status: Accepted

Solution code:
d,t,s=list(map(int,input().split()))
if(t*s<d):
  print("No")
else:
  print("Yes")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
print("Yes" if s*t >= d else "No")

Submission status: Accepted

Solution code:
D,T,S = [int(i) for i in input().split()]
if S*T >= D:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
if t*s >= d:
    ans = 'Yes'
else:
    ans = 'No'

print(ans)

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())
if d <= s*t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())
if d <= s*t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if T * S >= D:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D, T, S = list(map(int, input().split()))

if D <= S * T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
# input()
# int(input())
# map(int, input().split())
# list(map(int, input().split()))
# list(map(int, list(input()))) # スペースがない数字リストを読み込み
import math
import fractions
import sys
import bisect
import heapq  # 優先度付きキュー(最小値取り出し)
import collections
from collections import Counter
from collections import deque
import pprint
import itertools

"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""

def factorization(n):
    arr = []
    temp = n
    if n == 1:
        return arr

    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


# a^n
def power(a, n, mod):
    x = 1
    while n:
        if n & 1:
            x *= a % mod
        n >>= 1
        a *= a % mod
    return x % mod


# n*(n-1)*...*(l+1)*l
def kaijo(n, l, mod):
    if n == 0:
        return 1
    a = n
    tmp = n - 1
    while (tmp >= l):
        a = a * tmp % mod
        tmp -= 1
    return a

# Union Find
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 make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)

    divisors.sort()
    return divisors

inf = 10 ** 18
mod = 10 ** 9 + 7

_INPUT = """\
1000 15 80
"""

def main(*, input=input):
    sr = lambda: input()
    ir = lambda: int(sr())
    lr = lambda: list(map(int, sr().split()))

    d,t,s = lr()
    if s*t >= d:
        print('Yes')
    else:
        print('No')


if __name__ == "__main__":
    import io, sys

    # sys.stdin = io.StringIO(_INPUT)

    main()

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
ans = "Yes" if d / s <= t else "No"
print(ans)

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
if t*s >= d:
	print ("Yes")
else:
	print ("No")

Submission status: Accepted

Solution code:
nums=input().split()
t=int(nums[0])/int(nums[2])
if t<=int(nums[1]):
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
D, T, S=map(int, input().split())
if S*T-D>=0:print('Yes')
else:print('No')

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if T*S >= D:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int,input().split())
if D/S <= T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
print("Yes" if D <= T*S else "No")

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())
if D/S<=T:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
##A - Don't be late
D,T,S = map(int,input().split())
if D / S <= T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if S * T < D:
  print('No')
else:
  print('Yes')

Submission status: Accepted

Solution code:
x = input().split(' ')
x = list(map(int,x))
print("Yes") if (x[0]/x[1])<= x[2] else print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if D <= T*S:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:

from sys import stdin

input = stdin.readline().rstrip

#x = input().rstrip()
#n = int(input())

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

D,T,S = map(int, input().split(" "))

if(T * S >= D):
	print("Yes")
else:
	print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
print(
  'Yes' if d / s <= t else 'No'
)

Submission status: Accepted

Solution code:
# スペース区切りの整数の入力
D, T, S = map(int, input().split())
#積計算
# times = a*b
# 出力
if S*T < D:
	print("No")
else:
	print("Yes")

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())
if S*T>=D :
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if D / S <= T:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())

if D/S <= T:
    print('Yes')
else:
  	print('No')

Submission status: Accepted

Solution code:
D, T, S = map(int,input().split())
if D/S<=T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())

if D > S*T:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
print("Yes" if t>=d/s else "No")

Submission status: Accepted

Solution code:
# A - Don't be late

D, T, S = map(int, input().split())

if (D + S - 1) // S <= T:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s = [float(x) for x in input().split()]
if d/s > t:
  print("No")
else:
  print("Yes")

Submission status: Accepted

Solution code:
def solve():
    D,T,S = map(int,input().split())
    if T < D / S:
        print('No')
    else:
        print('Yes')
if __name__ == '__main__':
    solve()

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())
if D<=T*S:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
input_data = list(map(int, input().strip().split()))
if (input_data[0] / input_data[2] <= input_data[1]):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
def MI(): return map(int, input().split())
D,T,S=MI()
if D<=T*S:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
INPUT = input().split()
D = int(INPUT[0])
T = int(INPUT[1])
S = int(INPUT[2])

if D/S <= T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if d - t * s > 0:
    print('No')
else:
    print('Yes')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

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

Submission status: Accepted

Solution code:
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    D, T, S = LI()

    if T * S >= D:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    resolve()

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if d <= t*s:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
def main():
    D, T, S = map(int, input().split())
    speed = D / T
    if speed <= S:
        print("Yes")
    else:
        print("No")
if __name__ == '__main__':
    main()

Submission status: Accepted

Solution code:
NNN = list(map(int,input().split()))

print('Yes'if NNN[1]*NNN[2]>=NNN[0] else 'No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
B = D/S
if B > T:
    print("No")
else:
    print("Yes")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if (T * S >= D):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if (t * s >= d):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
s = input().split()
t = int(s[1])*int(s[2])
if (int(s[0]) <= t):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = input().split()
if int(D)/int(S) > int(T):
  print('No')
else:
  print('Yes')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if D <= T * S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())

if T * S >= D:
	print("Yes")
else:
	print("No")

Submission status: Accepted

Solution code:
data=str(input("")).split(" ")
D=int(data[0])
T=int(data[1])
S=int(data[2])

if D<=T*S:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
"""A."""

import sys

input = sys.stdin.readline  # noqa: A001

D, T, S = map(int, input()[:-1].split(' '))

print('Yes' if T * S >= D else 'No')

Submission status: Accepted

Solution code:
x, y, z = map(int, input().split())
if x <= y*z:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
if D <= T * S:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s=map(int, input().split());print(('Yes','No')[d/s>t])

Submission status: Accepted

Solution code:
n = input()
a = int(n.split()[0])
b = int(n.split()[1])
c = int(n.split()[2])
b = b * c
if (a <= b):
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
import base64
import subprocess


exe_bin = "e??420s#R400000000000{}h%0RR91&<Owl00000KmY&$00000s2czP0000000000Kma%Z2>?I<9RM5v1^@s61ONa4KmY&$00000KmY&$00000KmY&$00000_yGU_00000_yGU_000002mk;8000000{{R31ONa4I066w00000I066w00000I066w000008~^|S000008~^|S000000RR91000000RR911poj5000000000000000000000000000000*bD#w00000*bD#w00000001BW000000RR911^@s6Xbk`W00000Xbm6$00000Xbm6$00000r~&{0000007zF?T00000001BW000000ssI21^@s6fDHfu00000fDIr300000fDIr30000000IC20000000IC2000002mk;8000001ONa41ONa4R004100000R004100000R004100000L;wH)00000L;wH)000001ONa400000P~~)F1ONa4YzqJY00000YzqJY00000YzqJY00000L;wH)00000L;wH)000001ONa400000QRQ@G1^@s6000000000000000000000000000000000000000000000000005C8xG00000Qss1H1ONa4Xbk`W00000Xbm6$00000Xbm6$00000m;wL*00000m;wL*000000RR9100000FKlUIHZ(76WG!rIZgqGqcsMpKHZ(4CZ!R(b1ONa45C8xG0RR91M^04$000000{{R30ssI2000001ONa46aWAK0{{R3M^04$66o;Pv0SFPAbMN%YxTqg6IY|L0ssI24gdfE0RR911^@s6000mI0RRL54gdfE000006qpP{bCw4J000000000000000000000000000000fdBvi5&!@I00000000000000000000LID5(A^-pY00000000000000000000E&%`l5&!@I00000000000000000000RR9105&!@I00000000000000000000H30ws5&!@I000000000000000000009RUCU5&!@I00000000000000000000qW}N^5&!@I00000000000000000000@c;k-5&!@I000000000000000000009{>OVAOHXW00000000000000000000Q2_t|5&!@I000000000000000000005C8xGAOHXW00000000000000000000I{*LxAOHXW00000000000000000000X#fBK5&!@I000000000000000000002>}2A5datfKoB4R000005CH%H00000U;qFB5datfU=bhy000007y$qP000000BmVub97{5D=RK@Z!R_fUtec!Z*E_6bYXIIUta)UNmNZ=WMy(?XK8bEWpY$aLu_wuWmI8eY-IpnNmNZ=a%E>}b97~LR82!{Z*FB&VPb4$0AE^8Q)zN@MN(-1Us_XiGh=CP0AE^8Q*=0KZ*yN_VRL0PNp5L$L@`Bn0AE^8Q*=0KZ*yN_VRL0MHFJ4xV_$b^bZB35bYy97MPdM7T2pi}HeX+Fb98cLVQpV&ZgXXFbV*}VbTKhwXkl_+baG*7baP2#MMY9mbTKnxVRLC?UvG1Ca%Ev{NmO4{FkeMeHeXOnQ!`&|0AE^8Q*=0KZ*yN_VRL0PNp5L$Lor2m0AE^DbTngcb#wr1X<}n8b8jv-0AF8obYWv_Ut?%%UuI!xYyfj~a%^R80AF8Ycwt{*bY*yHbO2vpV|Za-W@&C=Y-xIB0AF8hX<}nvb97;HbYE>@X>I^VOi4mRUotK<07pzoLPK9NE;24P07pzoLPJ<sUo$Q=E;#^4Oi4mRSXf^(E;IlD000620{{a60ssR51ONp90ssI20{{R3000620ssO4000000RRF369E7K5C8xGFaQ7m6lrM<000C4V*vmF5C8xGbsA|200093Z2<rP000000RRF30RR915C8xG00000iGL{q000F5c>w?b5C8xGbSaVu00062hXDWp00000Xbm6$000002mk;800000&<X$m00000a19^;000002mk;800000pa}o~00000cnu%`000002mk;800000kO}|*000002oN9u000002mk;8000002oN9u00000&<`L0000001^@s60ssI20000000000*bg88000001^@s62><{90000000000;13`G000001^@s63IG5A0000000000=no(O000001^@s63jhEB0000000000@DCsW000001^@s63;+NC0000000000_zxfe000001^@s64FCWD0000000000KoB4R000001poj54gdfE0000000000U=bhy000001poj54*&oF0000000000m=7QT000002LJ#70RR910000000000pbsDb000002LJ#70{{R30000000000s1G0j000002LJ#71ONa40000000000un!;r000002LJ#71poj50000000000xDOxz000002LJ#71^@s60000000000zz-k*000002LJ#72LJ#70000000000$PXX@000002LJ#72mk;80000000000NQ3MMNQ(u%2Ot1Qg}`(I|IkQ-#0bLx0000000000|20AfAOQa*L<b-M4<A4P|0O~PAOL6p0002#;Q#;s|0OyHAOL6q0002#(EtDc|0Oa9AOL6r0002#!2kdM|0OC1AOL6s0002#u>b%6|0N;^AOL6t0002#p#T5>|0Nm+AOL6u0002#kpKVx|0NO!AOL6v0002#fdBvh|0N0sAOL2N0000000000Q!)QYjU9~w002mX>>y-Fiv%So0000;i9{qAF~I0u|Ns9;jdUaoNR2&V2p|AR#|1tKAOHXW008J=|Ns9;jdUasNQuYjRR90~NR4zP6iA83=tuwm|BFN<6iAIVFaiJo53fWd5IaO93`h@5-bjhx=okP0|45BJ@CG0NNQuHoiQec%|Ns9;jdUanNR2(&1|R^s0RR91#zZ6w3g{~T|NlsfOe7d&NHYv2C;$KebqGj<#2_)iTf^x6{{R0E9{^@94<Cd800000NR2(x2p|ARgX{?C0RR90NQ*r|1|R@PjTK4;AOJ{>HM9sI07!$x2<fu^|Nmx?G3`l-(OyW2;z)z!@K97tjRk4}002mh4f6m107#8J-2VUn{}tv1AOQ3aA4C8ENR2%S1|R@cNR0&n1|R@PIrvD4<#ZWHiv_v`AOJ{(z;q2=|KMgW4<Cd800000UBeF_KmcYg4<Cd800000NR2(o1t0)OjWxmrAOKZJDgH=_<w(K)14xPRNWthoNCC!3(f)K8NQ(u51t0)Og}`(SUH{-_4<Cd800000UBeF_KmcYg4<Cd800000fIZ;{AOHY$FGzzuF9jd~098nd<#Y^4i#=KeAOPqM{{R2zNdN!;#s#?tAOHbf!w(;T00000^TTEjA4C8ERY-~DUFl~3|NmwWA4C8EL03UmNr~4%RY6otjU{#hAOKZJjV*oxAOKTAiTz25_Dm_|NQ3MMNWuLB=nwt>|44=HbRaR?4<Cd800000Oo{qTiS|T^??L|*+(?7N0Z2LBb?Qii#0XnmL0myyL0&;$!;oe!4<Cd800000^TPlDNQ3MMNQ1-(!vFvP0RRF3PHzBNWpe-k0UHB5KmY&$2LJ#7)cpVdi~s-tRQ><|v;Y7AWc~mD%m4rYH2(kp@Bjb+Wd8sETmS$7bpQYV3;_TD<p2NwQ~>}06aWAK000000eVsZ0eBDr8w>{skO2n}6aWAK8~^|S0RI2~D*ylh00000000006aWAK000000eVsZ0eBDr8w>{skO2SyBme*a8~^|SK>YvzfB*mh01gmF4j4)g3wH>B06!W#Dl;S^000006aWAKL;wH)nEe0$2mk;80000000000AOHXWTmS$7ko^Du!vFvP06`8Ag91$sFaoR!4iG~Q2tf+~7ytkOfB*mhJpKRwE&u=k080)KUJeKV00000L;wH)oB#j-VE+IAWdHyG074EBj{-st7>)x)4j_#LLJla51xOAsh6YFuID-dG4nT4aI6)3DK@KQF4j@7f7(xyZLJkN35C8xG<NyEwi2nco0ssI20000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000&<X$m00000pa}o~00000kO}|*000000RR91000000RR91000000RR910000069E7K000003;+NC00000AP4{e000004FCWD00000R0{wA0000082|tP00000Xbm6$000008vp<R000005C8xG000008UO$Q00000cnu%`000008~^|S000002mk;800000_5S~F00000m;wL*000001poj500000Km-5)000001^@s600000zybgO000003IG5A00000lK}t#000003jhEB000007ytkO000006#xJL0000000000000000{{R300000fDa%5000000ssI200000r~m)}000006aWAK000002LJ#7000007XSbN00000cn1Ig000002LJ#700000SOx$9000002mk;800000AOQdX000002><{9000007ytkO000009smFU000002mk;800000`~UxM000000RR9900000{{R1P00000_yqs}00000|NsAQ000000ssI200000@c;jB00000)CB+l00000`TzfK000001ONa4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000fDIr30000000000000000000000000RtNw900000W(WWP00000b_f6f00000h6n%v00000mIwd<00000rU(E400000wg><K0000000000000000000000000000000000000000000000000000000000000000000000000002oN9u00000M?*t8AShL0b#8QZAU7^GE-)=Kbz*gHbagR)F*q(TG$|lAE;TMN0000000000000000000000000000000000000000000000{{U4I066w000000000000000000000{{X5R0041000000000000000000000{{a6bOHbX000000000000000000000{{d7m;wL*000000000000000000000{{g8zybgO000000000000000000000{{j9Km-5)000000000000000000000{{mA)CB+l000000000000000000000{{pB_yqs}000000000000000000000{{sCSOx$9000000000000000000000{{vDcn1Ig000000000000000000000{{yEAP4{e000000000000000000000{{#FKnMT;000000000000000000000{{&Gzz6^U000000000000000000000{{*H&<Fqk000000000000000000000{{;IR0{wA000000000000000000000{{>JU<&{M000000000000000000000{{^KYzqJY000000000000000000000{{{LunPbH000000000000000000000{{~MXbm6$000000000000000000000{|2Ncnu%`000000000000000000000{|5OfDIr3000000000000000000000{|8PfDa%5000000000000000000000{|BQ01zMm000000000000000000000{|ERKoB4R000000000000000000000{|HS000000000000000000000RR911OV~>000000000000000000002><{90ssyGpa}o~00000E&u=k000009RL6T0RR{Pc@iK1000000RR9100000EC2ui1OV~>00000000000000000000Hvj+t0ssyG015yA000000000000000IRF3v0ssyGKnef=000000000000000OaK4?0ssyGkO}|*000000000000000VgLXD0RR{PcoHB0000000RR9100000aR2}S0RR*Lcnu%`000000000000000m;e9(0ssyG&<X$m000000000000000qyPW_0RR&KXbm6$000000000000000EC2ui1OV~>00000000000000000000!vFvP0RR#J)C>Rs000000000000000000001OV~>00000000000000000000(EtDd000pHYzqJY000000000000000<NyEw0RR;MfDIr3000000000000000?EnA(000vJcnu%`000000000000000{r~^~000vJXbm6$0000000000000005di=I0RR>NfDa%5000000000000000CjkHe5C9hd5D*{$000000000000000c>(|cAOIHt01zMm000000000000000E&%`l5daVXU<&{M000001ONa400000Jplj!5&!@I00000000000000000000YykiOA^-pY00000000000000000000hyefq5&!@I000000000000000000007ytkO5&#YW&<Fqk00000!vFvP00000oB;p;5ds$g2oN9u000000000000000sQ~~05&!@I00000000000000000000>jD4(5&#bXR0{wA000000000000000!2tjO5&!@I00000000000000000000eF6Xg5&#YW&<Owl00000D*ylh00000+W`Oo5&!@I00000000000000000000zXAXN5&#PTAP4{e000000000000000_W=L^5ds$g5D*{$0000000000000000|Ed55&!@I00000000000000000000U;+RD5datfKoB4R000005CH%H00000cLD$a5C9hd01zMm000000000000000`2YX_5C9kefD#}8000000000000000gaQBn5C9ke5D*{$000000000000000kOBYz5&!@I00000000000000000000wE_SD5&#YW;0gc$00000WdHyG00000#R32TAOHXW00000000000000000000;Q{~v5&#YWPzwM6000000ssI200000@d5w<5datfU=bhy000007y$qP000002Lk{A5&!@I00000000000000000000CIbKfAOHXW00000000000000000000H3I+uAOHXW00000000000000000000PXhn|5&!@I000000000000000000000BvDuZZ2bE0AEK;PeMUVUte=|VqZyLZDDC{0AE^DbWAv3Uukb?ZfSG?V{&wJbaiHCE@J>>WpZU_X>)XCa$j_9Ut?@<Ze?=-UteTzUuSG@Vqt7wWOQ$Gb6;U~cmQK>ZE$R5bY)~NH#Rvq0AF8ZZ(nC@Z(?C=Uu1M|a&uo{b$DN9X>Ms>VRCX|d0%C2baHtBW^!R|WnW}<ZEbk~UteZ&VQpn!WOZ$Ad0%O6X>?y<a&lpLUuAA|a(Mt>Uq(_vO+{ZtPDEc{0AF86PE}t;NMA-$K}|(pNJLTqUqo3>K}|_R0AF8eZfSI1VRCX|d0%C2WB^}ZX>MtBUtw}`VR>J3bYXII0AEK;PeMUVUr$CxQ$<u?R6#;aMPC44Wn^J=VE|uAPhWF%WNB_+b#rB80AE^8Q*=0KZ*yN_VRL0MHFJ4xV_$b^bZB35bYy97MPfieM@&gVLs(c}GcGg$UteQ*VP9rxZeeU`dSyUBM@&gVLtip3GA=a$b98cSWo|$~M@&gVLtip3GA=a$UteT%Z(nF(Ze(m_0AE^8Q)zN@MN(-%Ku1hTLPJ<sUo$Q=0AF8Ycwt{*bY*yHbU;8yOi4mRUotK-E;RsOUvqR}V{2byXlq|)VQFkYKu1hTLPK9NE;ImNUsO#)UqwztUta)UT2pi}HeX+Fb98cLVQpV&ZgXXFbV*}VbTKhwXkl_+baG*7baP2#MMY9mbTKnxVRLC?UvG1Ca%Ev{NmO4{FkeMeHeXOnQ!`&|KtM-KNkT(dSYI<PG%h&+Us_XiG-GddbU;8yOi4mRSXf^(E;ImNUu0o)VPA7}VRCc;UteN#b6<0GVRCc;Us_I6bU0~mb6;X%b7eG1ZfSHwF-3MjKu1hTLPJ<sUo$Q=0AF8hX<}nvV{>(1X>MtB0AEQ|O<!bXa%E>}b97~LR82!{Z*FB&VPb4$0AF8hX<}nvV{>(1W@&C|0AE^DbTeaVZa_dsOi4mRSXf^(E;ImNUu<b&V_$Q0VRCd|ZDDC{KtM-KNkT(kGA=SMH2_~<XKin8UvqR}a&%u`0AEQ|O<!_lXK8bEWpY$aLu_wuWmI8eY-IpnT251RIB9QlUt(c%Wi&}{X>>#}MRq_yM@&gVLs(c}GcGg$04{TRZFFH`04{TMa&%#004{TAb98caVPXI-X>N37a&Q1HZf|sDE<r*`Ep%aL04{ECbY(7QZgnnVb!lv5Eoo!`E@y6aE@)wMXaFu`d2VxgZ2&H0d2VxbasV!8ZgnnpWpZ<AZ*BlCXKr;ac4cyNX>V>{asV!JWo%(CWO;4?E^=jTVJ>iNbO0`CZfSG?E^usgE@y9a04{W8cys_RW@&C|04{QGWMOn+04`-{UuJS)ZDn6*WO4v5WoTb!a$#*{04`~6X>?y<a&lpL04`=}ZfRd(a&lpL04`*CZeeX{V*oB>VRT^tE@E?Y04`&1ZEa<4bN~PV00000000000000000000000000000000000000000000000000000000000000000000000000000000000008vp<R0RR910ssI200000I066w00000I066w000008~^|S0000000000000000RR91000000000000000BLDyZ2LJ#70ssI200000R004100000R004100000AOHXW0000000000000001ONa4000000000000000F#rGn2LJ#70ssI200000bOHbX00000bOHbX00000Bme*a0000000000000001ONa4000000000000000L;wH)_W%EH0ssI200000m;wL*00000m;wL*00000C;$Ke000001poj5000002mk;8000000000000000P5=M^3jhEB0ssI200000zybgO00000zybgO00000fB^si000001^@s60RR912mk;8000007ytkO00000RsaA10{{R30ssI200000Km-5)00000Km-5)00000lK}t#0000000000000000RR91000000000000000UH||9|NsAQ0ssI200000)CB+l00000)CB+l00000AOHXW000001poj5000000ssI2000000ssI200000YXATM{{R1P0ssI200000_yqs}00000_yqs}00000U;qFB000001^@s60ssI22mk;8000000000000000dH?_b1ONa40ssI200000SOx$900000SOx$900000AOQdX000001poj5000002mk;8000007ytkO00000ga7~l1ONa4LI3~&00000cn1Ig00000cn1Ig00000r~m)}000001poj5761SM2mk;8000007ytkO00000jsO4v0RR911^@s600000AP4{e00000AP4{e000007XSbN0000000000000001ONa4000000000000000i2wiq0RR911^@s600000KnMT;00000KnMT;00000fB*mh0000000000000005C8xG000005C8xG00000lmGw#0RR911^@s600000zz6^U00000zz6^U000002mk;80000000000000002mk;8000002mk;800000od5s;0RR911^@s600000&<Fqk00000&<Fqk00000f&u^l0000000000000005C8xG000000000000000qW}N^0RR911^@s600000R0{wA00000R0{wA000002><{90000000000000001ONa4000000000000000sQ>@~0RR910ssI200000U<&{M00000U<&{M000003jhEB0000000000000001ONa4000000000000000u>b%70RR910ssI200000YzqJY00000YzqJY00000L;wH)0000000000000001ONa4000000000000000zW@LL0RR910ssI200000unPbH00000unPbH00000C;<Qf0000000000000002mk;8000000000000000$p8QV4gdfE0{{R300000Xbm6$00000Xbk`W000005C8xG0000000000000002mk;8000002mk;800000)c^nh4*&oF0{{R300000cnu%`00000cntsm000002mk;80000000000000002mk;8000002mk;800000;Q#;t1^@s60{{R300000fDIr300000fDHfu0000000IC2000001^@s6000002mk;8000005C8xG00000m;e9(0RR910{{R300000fDa%500000fDZrw00000fB*mh0000000000000002mk;8000002mk;800000>Hq)$0RR910{{R30000001zMm0000001yBG000005C8xG0000000000000002mk;8000000000000000@Bjb+2mk;80{{R300000KoB4R000005D)+W00000Kmq^&000000000000000KmY&$000000000000000^#A|>0RR91FaQ7m0000000000000005D)+W00000DF6Tf0000000000000000RR91000000RR91000000RR910ssI200000000000000000000Ko9@`00000@CE<?000008vp<REdT%j2mk;8000007ytkO000002><{90{{R300000000000000000000Fc$y-00000bOQhY0000000000000000RR910000000000000005dZ)H0{{R300000000000000000000q#6JK00000{r~^~0000000000000000RR91000000000000000"

open("./kyomu", 'wb').write(base64.b85decode(exe_bin))
subprocess.run(["chmod +x ./kyomu"], shell=True)
subprocess.run(["./kyomu"], shell=True)

Submission status: Accepted

Solution code:

#入力:N,M(int:整数)
def input2():
	return map(int,input().split())
  
d,t,s=input2()
if d/s >t:
	print("No")
else:
	print("Yes")

Submission status: Accepted

Solution code:
x, y, z = [int(a) for a in input().split()]
if y*z>=x:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
m, s, mps = [int(x) for x in input().split()]
time = m / mps

if s >= time:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
data = input()
data = data.split()
print("Yes") if int(data[0]) / int(data[2]) <= int(data[1]) else print("No")

Submission status: Accepted

Solution code:

def main(D, T, S):
    print('Yes' if D <= T * S else 'No')

if __name__ == '__main__':
    D, T, S = map(int, input().split())
    main(D, T, S)

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
if D/S <= T:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
if t*s>=d:
  print("Yes")
else:
  print('No')

Submission status: Accepted

Solution code:
d,t,s = map(int, input().split())
if d/s <= t:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())
if D/S<=T:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int,input().split())

if(d/s <= t):
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
D,T,S=map(int,input().split())

if T >= D/S:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int,input().split())

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

Submission status: Accepted

Solution code:
#!/usr/bin/python3
 
cmdvar_numlist=input()
cmdvar_spritd=cmdvar_numlist.split()
D,T,S=list(map(int,cmdvar_spritd))

if D/S<=T:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if d/s<=t:
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
if d/s <= t:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
D, T, S = map(int, input().split())
print("Yes" if D/T <= S else "No")

Submission status: Accepted

Solution code:
d,t,s=map(int,input().split())
if(s>=(d/t)):
    print("Yes")
else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int, input().split())
if D/S <= T:
  print("Yes")
else:
  print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
print('YNeos'[D/S>T::2])

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())
if d/s<=t:
    print('Yes')
else:
    print('No')

Submission status: Accepted

Solution code:
d, t, s = map(int, input().split())

if d<= t*s:
  print('Yes')
else:
  print('No')

Submission status: Accepted

Solution code:
list =input().split()

list = [int(i) for i in list]

D=list[0]

S=list[1]

T=list[2]


if(D/S<=T):
	print("Yes")
else:
	print("No")

Submission status: Accepted

Solution code:
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy
 
def main():
    d,t,s = map(int, input().split())
    if d <= t*s:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
d,t,s = map(int,input().split())
if d/s <= t:
    print("Yes")

else:
    print("No")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())
 
if D > T*S :
 print("No")
else:
  print("Yes")

Submission status: Accepted

Solution code:
D,T,S = map(int,input().split())

if D > T*S :
  print("No")
else:
  print("Yes")