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.

Solution (Python):
import sys,bisect

from sys  import stdin,stdout

from bisect import bisect_left,bisect_right,bisect,insort,insort_left,insort_right

from math import gcd,ceil,floor,sqrt

from collections import Counter,defaultdict,deque,OrderedDict

dx=[-1,1,0,0]
dy=[0,0,1,-1]


sys.setrecursionlimit(10**6)
INF = float('inf')
MOD = 998244353
mod = 10**9+7

def isPrime(n):
    if (n <= 1) :return False
    if (n <= 3) :return True
    if (n%2 == 0 or n%3 == 0):return False
    for i in range(5,ceil(sqrt(n))+1,6):
        if (n%i==0 or n%(i+2)==0):
            return False
    return True

def st():
    return list(stdin.readline().strip())

def inp():
    return int(stdin.readline())

def li():
    return list(map(int,stdin.readline().split()))

def mp():
    return map(int,stdin.readline().split())

def pr(n):
    stdout.write(str(n)+"\n")


def soe(limit):
    l=[1]*(limit+1)
    l[0]=0
    l[1]=0
    prime=[]
    for i in range(2,limit+1):
        if l[i]:
            for j in range(i*i,limit+1,i):
                l[j]=0
    
    for i in range(2,limit+1):
        if l[i]:
            prime.append(i)
    return prime

                
def gcd(a,b):
    while b:
        a=a%b
        b,a=a,b
    return a

def power(a,n):
    r=1
    while n:
        if n&1:
            r=(r*a)
        a*=a
        n=n>>1
    return r
    
def solve():
    d,t,s=mp()
    if s*t>=d:
        print('Yes')
    else:
        print('No')



for _ in range(1):
    solve()

Solution (Python):
import sys
sys.setrecursionlimit(10**6)


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


if __name__ == '__main__':
    main(sys.stdin.readline, print)

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

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

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

Solution (Python):
[d,t,s] = list(map(int, input().split()))
if t*s >= d:
    print('Yes')
else:
    print('No')

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

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

Solution (Python):
from sys import setrecursionlimit
from collections import Counter
from collections import defaultdict
from collections import deque
from heapq import heapify
from heapq import heappop
from heapq import heappush
from time import time
setrecursionlimit(10**9)
mod=10**9+7
inf=10**18

d,t,s=[int(x) for x in input().split()]

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

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

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

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
D, T, S = [int(n) for n in input().split()]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):
a, b, c = map(int,input().split())
if(a / c <= b):
  print("Yes")
else:
  print("No")

Solution (Python):
D, T, S = [int(n) for n in input().split()]
print('Yes' if D/S <= T else 'No')

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

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush

def main():
    d,t,s = map(int, input().split())

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


if __name__ == '__main__':
    main()

Solution (Python):
D, T, S = [int(a) for a in input().split()]

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

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

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

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

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

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

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

r = d/s

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

Solution (Python):






import math
import statistics
import numpy as np
import queue
import itertools
import functools 

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

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

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

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

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

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

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

Solution (Python):


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

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

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

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

Solution (Python):
import sys
from io import StringIO
import unittest


def resolve():
    
    
    d, t, s = map(int, input().split())
    

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

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """1000 15 80"""
        output = """Yes"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """2000 20 100"""
        output = """Yes"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """10000 1 1"""
        output = """No"""
        self.assertIO(input, output)


if __name__ == "__main__":
    
    resolve()

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

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

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

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

ans = ["No","Yes"]
print(ans[int(T*S >= D)])

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

d,t,s = map(int, readline().split())

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

Solution (Python):
import math
D, T, S = map(int, input().split())


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

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

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

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

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

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

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

Solution (Python):
import math
import itertools
import sys
d, t, s = map(int, input().split())
if(t*s >= d):
    print("Yes")
else:
    print("No")

Solution (Python):


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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
d,t,s=map(int,input().split())
print(["No","Yes"][d/s<=t])

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

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

Solution (Python):



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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
import math
import bisect
from sys import stdin,stdout
from math import gcd,floor,sqrt,log
from collections import defaultdict as dd
from bisect import bisect_left as bl,bisect_right as br

sys.setrecursionlimit(100000000)

ii     =lambda: int(input())
si     =lambda: input()
jn     =lambda x,l: x.join(map(str,l))
sl     =lambda: list(map(str,input().strip()))
mi     =lambda: map(int,input().split())
mif    =lambda: map(float,input().split())
lii    =lambda: list(map(int,input().split()))

ceil   =lambda x: int(x) if(x==int(x)) else int(x)+1
ceildiv=lambda x,d: x//d if(x%d==0) else x//d+1

flush  =lambda: stdout.flush()
stdstr =lambda: stdin.readline()
stdint =lambda: int(stdin.readline())
stdpr  =lambda x: stdout.write(str(x))

mod=1000000007



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

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

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

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

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

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

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

else:
    print("No")

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

Solution (Python):
import sys
import math
import copy
import heapq
import random
from functools import cmp_to_key
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter




input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]

INF = float("inf")
MOD = 10 ** 9 + 7
divide = lambda x: pow(x, MOD - 2, MOD)


def nck(n, k, kaijyo):
    return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD


def npk(n, k, kaijyo):
    if k == 0 or k == n:
        return n % MOD
    return (kaijyo[n] * divide(kaijyo[n - k])) % MOD


def fact_and_inv(SIZE):
    inv = [0] * SIZE  
    fac = [0] * SIZE  
    finv = [0] * SIZE  
    inv[1] = 1
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    for i in range(2, SIZE):
        inv[i] = MOD - (MOD // i) * inv[MOD % i] % MOD
        fac[i] = fac[i - 1] * i % MOD
        finv[i] = finv[i - 1] * inv[i] % MOD

    return fac, finv


def renritsu(A, Y):
    
    
    
    A = np.matrix(A)
    Y = np.matrix(Y)
    Y = np.reshape(Y, (-1, 1))
    X = np.linalg.solve(A, Y)

    
    return X.flatten().tolist()[0]


class TwoDimGrid:
    
    def __init__(self, h, w, wall="
        self.h = h
        self.w = w
        self.size = (h + 2) * (w + 2)
        self.wall = wall
        self.get_grid()
        

    def get_grid(self):
        grid = [self.wall * (self.w + 2)]
        for i in range(self.h):
            grid.append(self.wall + getS() + self.wall)

        grid.append(self.wall * (self.w + 2))
        self.grid = grid

    def init_cost(self):
        self.cost = [INF] * self.size

    def pos(self, x, y):
        
        return y * (self.w + 2) + x

    def getgrid(self, x, y):
        return self.grid[y][x]

    def get(self, x, y):
        return self.cost[self.pos(x, y)]

    def set(self, x, y, v):
        self.cost[self.pos(x, y)] = v
        return

    def show(self):
        for i in range(self.h + 2):
            print(self.cost[(self.w + 2) * i:(self.w + 2) * (i + 1)])

    def showsome(self, tgt):
        for t in tgt:
            print(t)
        return

    def showsomejoin(self, tgt):
        for t in tgt:
            print("".join(t))
        return

    def search(self):
        grid = self.grid
        move = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        move_eight = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 1), (1, -1), (-1, 1), (-1, -1)]
        
        
        
        
        


def solve():
   d, t,s  = getList()
   if s * t >= d:
       print("Yes")
   else:
       print("No")

if __name__ == "__main__":
    
    solve()

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

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

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

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

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

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

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

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

Solution (Python):
def cin():  return list(map(int,input().split()))

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

Solution (Python):
D,T,S=map(int,input().split())
ans="No"

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

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

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

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

Solution (Python):
d, s, t = [int(i) for i in input().split()]
if d <= s * t:
  print("Yes")
else:
  print("No")

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

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

Solution (Python):


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

if c>=s:
	print("Yes")
else:
	print("No")

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

if a/c <= b:
    print("Yes")
else:
    print("No")

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

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

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

Solution (Python):
import sys, io, os, re
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from pprint import pprint
from math import sin, cos, pi, radians, sqrt, floor, ceil
from copy import copy, deepcopy
from collections import deque, defaultdict
from fractions import gcd
from functools import reduce
from itertools import groupby, combinations
from heapq import heapify, heappush, heappop



n1 = lambda: int(sys.stdin.readline().strip())
nn = lambda: list(map(int, sys.stdin.readline().strip().split()))
f1 = lambda: float(sys.stdin.readline().strip())
fn = lambda: list(map(float, sys.stdin.readline().strip().split()))
s1 = lambda: sys.stdin.readline().strip()
sn = lambda: list(sys.stdin.readline().strip().split())
nl = lambda n: [n1() for _ in range(n)]
fl = lambda n: [f1() for _ in range(n)]
sl = lambda n: [s1() for _ in range(n)]
nm = lambda n: [nn() for _ in range(n)]
fm = lambda n: [fn() for _ in range(n)]
sm = lambda n: [sn() for _ in range(n)]

def array1(n, d=0): return [d] * n
def array2(n, m, d=0): return [[d] * m for x in range(n)]
def array3(n, m, l, d=0): return [[[d] * l for y in xrange(m)] for x in xrange(n)]
def linc(A, d=1): return list(map(lambda x: x + d, A))
def ldec(A, d=1): return list(map(lambda x: x - d, A))


D, T, S = nn()

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

Solution (Python):
def inp():
    return input()
def iinp():
    return int(input())
def inps():
    return input().split()
def miinps():
    return map(int,input().split())
def linps():
    return list(input().split())
def lmiinps():
    return list(map(int,input().split()))
def lmiinpsf(n):
    return [list(map(int,input().split()))for _ in range(n)]

d,t,s = miinps()

k = d/s

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

Solution (Python):
import math
from collections import defaultdict
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:input()

"""========main code==============="""
t=1

for _ in range(t):
    a,b,c=ml()
    if(b*c>=a):
        print("Yes")
    else:
        print("No")

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

if (B*C) >= A:
	print("Yes")
else:
	print("No")

Solution (Python):






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





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

Solution (Python):
def main():
    d,t,s = [int(v) for v in input().split()]
    print('Yes' if d<=t*s else 'No')

main()

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

Solution (Python):
D, T, S = [int(_n) for _n in input().split()]

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

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

Solution (Python):
import math
import collections
import itertools

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

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

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

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

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

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

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

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

Solution (Python):

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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):
def main():
    d, t, s = [int(x) for x in input().split()]
    if s * t >= d:
        return 'Yes'
    else:
        return 'No'


if __name__ == '__main__':
    print(main())

Solution (Python):




import sys
from io import StringIO
import unittest

def yn(b):
    print("Yes" if b==1 else "No")
    return

def resolve():
    readline=sys.stdin.readline

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

    return

if 'doTest' not in globals():
    resolve()
    sys.exit()

Solution (Python):



def main():
    D, T, S = map(int, open(0).read().split())
    if D <= S * T:
        print("Yes")
    else:
        print("No")


main()

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

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

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

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

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

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

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

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

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

Solution (Python):
def main():
    D, T, S = list(map(int, input().split()))

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
def main():
    import sys
    sys.setrecursionlimit(10**6)
    input = sys.stdin.readline
    D, T, S = [int(x) for x in input().strip().split()]
    if D / S <= T:
        print('Yes')
    else:
        print('No')

if __name__ == '__main__':
    main()

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

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


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

Solution (Python):
d, t, s = (int(each) for each in input().split())
if s * t >= d:
    print('Yes')
else:
    print('No')

Solution (Python):
def resolve():
    D,T,S = map(int,input().split())

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


resolve()

Solution (Python):


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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

Solution (Python):
from functools import reduce
from fractions import gcd
import math
import bisect
import itertools
import sys
input = sys.stdin.readline
INF = float("inf")



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

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


if __name__ == '__main__':
    main()

Solution (Python):
d,t,s=map(int,input().split())
print(['No','Yes'][d<=s*t])

Solution (Python):
def main():
    d,t,s = list(map(int, input().split(" ")))
    if d - t*s > 0:
        print("No")
    else:
        print("Yes")

if __name__=="__main__":
    main()

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
D,T,S = LI()
print('Yes' if D/S<=T else 'No')

Solution (Python):
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy


import heapq
sys.setrecursionlimit(10**6)

INF = 10**18
import bisect
import statistics
mod = 10**9+7


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

if (a <= b*c):
    print("Yes")
else:
    print("No")

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

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

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

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

Solution (Python):
D, T, S = [int(n) for n in input().split(" ")]

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def input(): return sys.stdin.readline().rstrip()

def main():
    d,t,s = map(int, input().split())
    if (s * t) < d:
        print('No')
    else:
        print('Yes')


if __name__ == '__main__':
    main()

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

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

Solution (Python):

d, t, s = [int(x) for x in input().strip().split()]

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

Solution (Python):

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

time = d/t

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

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

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

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

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

Solution (Python):
'''
Created on 2020/08/29

@author: harurun
'''
def main():
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write
  
  D,T,S=map(int,pin().split())
  if S*T>=D:
    print("Yes")
  else:
    print("No")
  return 
main()

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


if __name__ == '__main__':
    main()

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

print(['No','Yes'][D<=T*S])

Solution (Python):

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

Solution (Python):
import sys
input = sys.stdin.readline
D,T,S= map(int,input().split())

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

Solution (Python):
def main():
    D, T, S = map(int, input().split())

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


if __name__ == "__main__":
    main()

Solution (Python):
ni = lambda: int(input())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

d,t,s = nm()

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

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

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

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

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

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

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

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

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

Solution (Python):

import os
from sys import stdin, stdout
    
    
def solve(tc):
    d, t, s = map(int, stdin.readline().split())

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

    
tcs = 1
tc = 1
while tc <= tcs:
    solve(tc)
    tc += 1

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

ans = 'Yes' if T*S>=D else 'No'

print(ans)

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):



def ri():
    return int(input())

def rl():
    return list(input().split())

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

def main():
    d, t, s = rli()
    if t*s >= d:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):

import sys

YES = "Yes"  
NO = "No"  


def solve(D: int, T: int, S: int):
    return YES if D / S <= T else NO



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    D = int(next(tokens))  
    T = int(next(tokens))  
    S = int(next(tokens))  
    print(solve(D, T, S))

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    
    main()

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

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

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

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