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 os
import heapq
import sys,threading
import math
import bisect
import operator
from collections import defaultdict
sys.setrecursionlimit(10**5)
from io import BytesIO, IOBase
def gcd(a,b):
    if b==0:

        return a
    else:
        return gcd(b,a%b)
def power(x, p,m):
    res = 1
    while p:
        if p & 1:
            res = (res * x) % m
        x = (x * x) % m
        p >>= 1
    return res
def inar():
    return [int(k) for k in input().split()]

def lcm(num1,num2):
    return (num1*num2)//gcd(num1,num2)

def main():
    
    t=1
    for _ in range(t):

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

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

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):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations,product

from heapq import heapify,heappop,heappush

from functools import reduce,lru_cache

from decimal import Decimal
from argparse import ArgumentParser

args=ArgumentParser()
args.add_argument('-loc', '--local', type=bool,default=False)
LOCAL=args.parse_args().local

def input(): 
    x=sys.stdin.readline(); 
    if x[-1]=="\n": 
        return x.rstrip() 
    return x
    
def printe(*x):_=print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): 
    x= x - ((x >> 1) & 0x5555555555555555)
    x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f 
    x+= (x >> 8); x+= (x >> 16); x+= (x >> 32) 
    return x & 0x7f

def main():
    mod = 1000000007
    

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

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


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
from math import sqrt, gcd, ceil, log, floor
from bisect import bisect, bisect_left
from collections import defaultdict, Counter, deque
from heapq import heapify, heappush, heappop
input = sys.stdin.readline
read = lambda: list(map(int, input().strip().split()))

def main():
	d, t, s = read()
	print("YNeos"[d/s > t::2])


if __name__ == "__main__":
	main()

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

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

Solution (Python):
from sys import stdin

def main():
    d, t, s = [int(x) for x in stdin.readline().rstrip().split()]

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

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()))
tt=d/s
if tt<=t:
  print("Yes")
else:
  print("No")

Solution (Python):

import sys

YES = "Yes"  
NO = "No"  


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



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))  
    solve(D, T, S)

if __name__ == '__main__':
    main()

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

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

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

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

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

Solution (Python):
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 D/S<=T:
    print('Yes')
else:
    print('No')

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

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

if __name__ == "__main__":
  resolve()

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

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

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

Solution (Python):













from sys import stdin
from operator import itemgetter
from collections import deque, Counter
import math
import pprint
from functools import reduce
import numpy as np
import random
import bisect
import copy
import time



MOD = int(1e9+7)
INF = float('inf')
alpha = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]

def keta(kazu): 
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers): 
    return reduce(math.gcd, numbers)

def combination(m,n): 
    
    if n > m:
        return 'すまん'
    return math.factorial(m) // (math.factorial(m-n) * math.factorial(n))

def pow_k(x,n):  
    if n == 0:
        return 1
    K = 1
    while n > 1:
        if n % 2 != 0:
            K *= x
        x *= x
        n //= 2
    return K * x

def fact(n): 
    arr = {}
    temp = n
    for i in range(2,int(n**0.5)+1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //= i
            arr[i] = cnt
    if temp != 1:
        arr[temp] = 1
    if arr == {}:
        arr[n] = 1
    return arr
    
def main():
    D,T,S = [int(x) for x in stdin.readline().rstrip().split()]
    if T*S >= D:
        print("Yes")
    else:
        print("No")
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 <= 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/S > T:
  print('No')
else:
  print('Yes')

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

Solution (Python):
d,t,s = map(int, input().split())
a = d/s
if a > t:
    print('No')
    exit()
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 S*T>=D:
    print('Yes')
else:
    print('No')

Solution (Python):
d,t,s=map(int,input().split())
print('YNeos'[d>t*s::2])

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>=0:
  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 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):
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("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())
x = D / S
if x <= T:
  print("Yes")
else:
  print("No")

Solution (Python):
d,t, s = [int(i) for i in input().split()]
if t*s >= d:
    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())

if T*S >= D:
    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 / s <= t:
    print("Yes")
else:
    print("No")

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

print( 'Yes' if T*S>=D else '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("No")
else:
    print("Yes")

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):
def l_in(type_): return list(map(type_, input().split()))
def i_in(): return int(input())
def m_in(type_): return map(type_, input().split())
def r_in(n, type_): return [type_(input()) for _ in range(n)]
ans = None

d, t, s = m_in(int)
ans = 'Yes' if d <= t*s else 'No'

print(ans)

Solution (Python):
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    D, T, S = map(int, input().split())
    if T*S >= D:
        print('Yes')
    else:
        print('No')


if __name__ == '__main__':
    solve()

Solution (Python):
r=input().split()
D=int(r[0])
T=int(r[1])
S=int(r[2])
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):
a,b,c=map(int,input().split())
d=a/c
if b>=d:
    print('Yes')
else:
    print('No')

Solution (Python):
from math import gcd

from math import factorial as f

from math import ceil, floor, sqrt
import math

import bisect
import re
import heapq

from copy import deepcopy
import itertools
from itertools import permutations

from sys import exit

ii = lambda: int(input())
mi = lambda: map(int, input().split())
li = lambda: list(map(int, input().split()))

yes = "Yes"
no = "No"


def main():
    d, t, s = mi()

    if s * t >= d:
        print(yes)
    else:
        print(no)


main()

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

if a/c <= b:
    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())
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 = list(map(int, input().split()))

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

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

a = D / S

if a <= 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):
from math import ceil
from collections import defaultdict, deque


def A(d, t, s):
  if t * s >= d:
    return 'Yes'
  return 'No'


def B(n):
  pass


def C(n, a):
  pass


def D(n):
  pass


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


if __name__ == '__main__':
  main()

Solution (Python):
D,T,S = map(int,input().split())
k = D/S
if T >= k:
    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):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor
from operator import mul
from functools import reduce


sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().rstrip().split()
def S(): return sys.stdin.readline().rstrip()
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def LSR(n): return [LS() for i in range(n)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]

mod=10**9+7
d,t,s=LI()
ret=0
if d%s:
    ret=1
if d//s+ret<=t:
    print("Yes")
else:
    print("No")

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

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

Solution (Python):
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mat = lambda x, y, v: [[v]*y for _ in range(x)]
ten = lambda x, y, z, v: [mat(y, z, v) for _ in range(x)]
mod = 1000000007
sys.setrecursionlimit(1000000)

D, T, S = rl()

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

Solution (Python):
"""
task statement
==============

高橋君は青木君と待ち合わせをしています。
待ち合わせ場所は高橋君の家から D メートル離れた地点であり、待ち合わせの時刻は T 分後です。
高橋君は今から家を出発し、分速 S メートルで待ち合わせ場所までまっすぐ移動します。
待ち合わせに間に合うでしょうか？

io_style
-------
D T S
"""
import sys



def input():
    return sys.stdin.readline().strip()


def input_int():
    return int(input())


def input_int_list():
    return [int(i) for i in input().split()]


def main():
    d, t, s = input_int_list()
    if d / s <= t:
        print("Yes")
    else:
        print("No")

    return


if __name__ == "__main__":
    main()

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 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())
if D/S >T:
  print("No")
else:
  print("Yes")

Solution (Python):
D, T, S = list(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("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())

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


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 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(i) for i in 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 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 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 = map(int, input().split())

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

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


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

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

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

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

Solution (Python):
d,t,s=list(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('Yes')
else:
    print('No')

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

Solution (Python):
def main():

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

    if b * c >= a:
        print('Yes')
    else:
        print('No')

if __name__=='__main__':
    main()

Solution (Python):
d,t,s=map(int,input().split())
print("Yes" if t*s>=d else "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 <= t * s:
    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())
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):
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 = [int(i) for i in input().split()]
print("Yes" if t*s >= d else "No")

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

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

Solution (Python):



import sys
from io import StringIO
import unittest


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)


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


if __name__ == "__main__":
    
    resolve()

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

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

Solution (Python):
D, T,S = map(int, input().split())
t = D / S
if t <= 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 = (int(T) for T in input().split())
print(['No','Yes'][D<=T*S])

Solution (Python):
import math

d,t,s = list(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('No')
else:
    print('Yes')