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 math
import fractions
import collections
import itertools
D,T,S=map(int,input().split())
time=D/S
if time<=T:
    print("Yes")
else:
    print("No")

Solution (Python):

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

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

Solution (Python):


import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())

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

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

if __name__ == "__main__":
    resolve()

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 > 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):
in0 = input().split()
D = int(in0[0])
T = int(in0[1])
S = int(in0[2])

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

Solution (Python):
def main():
    d, t, s = map(int, input().split())
    if t*s >= d:
        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 = map(int,input().split())
if d/s <= t:
    print("Yes")
else:
    print("No")

Solution (Python):
from math import floor, ceil, sqrt, factorial, log, gcd
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop
import copy
import numpy as np
import sys
INF = float('inf')
mod = 10**9+7


def lcm(a, b): return a * b / gcd(a, b)





def LI(): return list(map(int, sys.stdin.buffer.readline().split()))




def I(): return int(sys.stdin.buffer.readline())





def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()




def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')







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


if __name__ == "__main__":
    main()

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

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


if __name__ == '__main__':
    main()

Solution (Python):
D, T, S = map(int, input().split())
if D - T*S <= 0:
  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 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 S*T >= D:
    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-t*s <= 0:
  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 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 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):



import queue 




    






mod = int(1e9+7)

INF = 1<<50

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

def main():
    d,t,s = readInt()
    if s*t<d:
        print("No")
    else:
        print("Yes")
    return

if __name__=='__main__':
    main()

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 = list(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 d / s <= t:
    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 = map(int,input().split())
if t*s >= d:
  print('Yes')
else:
  print('No')

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

t = D // S
if D % S != 0: t += 1

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

Solution (Python):

from functools import reduce
from queue import Queue
from collections import deque

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

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

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

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

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

bl = s * t >= d

print("Yes" if bl else "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())

    hun = d / s

    if t >= hun:
        print('Yes')
    else:
        print('No')


if __name__ == "__main__":
    main()

Solution (Python):


import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

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

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

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
from math import floor, sqrt, factorial, hypot, log  
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement
from bisect import bisect_left, bisect_right
from copy import deepcopy
from fractions import gcd
from random import randint


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


inf = float('inf')
mod = 10 ** 9 + 7


def pprint(*A):
    for a in A:     print(*a, sep='\n')


def INT_(n): return int(n) - 1


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


def MF(): return map(float, input().split())


def MI_(): return map(INT_, input().split())


def LI(): return list(MI())


def LI_(): return [int(x) - 1 for x in input().split()]


def LF(): return list(MF())


def LIN(n: int): return [I() for _ in range(n)]


def LLIN(n: int): return [LI() for _ in range(n)]


def LLIN_(n: int): return [LI_() for _ in range(n)]


def LLI(): return [list(map(int, l.split())) for l in input()]


def I(): return int(input())


def F(): return float(input())


def ST(): return input().replace('\n', '')


def main():
    D, T, S = LI()
    if D / S <= T:
        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):
import sys
from sys import exit
from math import gcd, factorial, ceil, floor, sqrt
from bisect import bisect_left, bisect_right
from copy import deepcopy
from heapq import heapify, heappop, heappush
from itertools import permutations, combinations, product, accumulate
from collections import defaultdict, deque, Counter
sys.setrecursionlimit(10**7)

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

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

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

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

Solution (Python):









def solve():
    d, t, s = map(int, input().split())
    p = s * t
    if d > p:
        return "No"
    return "Yes"


def main():
    print(solve())


if __name__ == "__main__":
    main()

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

x=t*s

if x>=d:
  print('Yes')
  
else:
  print('No')

Solution (Python):
def resolve():
    '''
    code here
    '''
    D, T, S = [int(item) for item in input().split()]

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


if __name__ == "__main__":
    resolve()

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 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):
from sys import stdin, setrecursionlimit

setrecursionlimit(10 ** 7)

from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter
from itertools import combinations, permutations, combinations_with_replacement
from itertools import accumulate
from math import ceil, sqrt, pi, radians, sin, cos

MOD = 10 ** 9 + 7
INF = 10 ** 18


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

print("Yes") if D <= T * S 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):
import sys
import math
import collections
import bisect
import itertools
import decimal




INF = 10 ** 20
MOD = 10 ** 9 + 7


ni = lambda: int(sys.stdin.readline().rstrip())
ns = lambda: map(int, sys.stdin.readline().rstrip().split())
na = lambda: list(map(int, sys.stdin.readline().rstrip().split()))
na1 = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().rstrip().split()))




def main():
    d, t, s = ns()
    flg = d <= t * s
    print("Yes" if flg else "No")


if __name__ == '__main__':
    main()

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

Solution (Python):


'''
Author: andyli
Time: 2020-08-29 19:58:33
'''

import os
from io import BytesIO, IOBase
import sys


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

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



BUFSIZE = 1048576


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)
def input(): return sys.stdin.readline().rstrip('\r\n')




if __name__ == '__main__':
    main()

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

Solution (Python):
import math
n,k,t=map(int,input().split())
h=n/t
if h<=k:
    print('Yes')
else:
    print('No')

Solution (Python):


from queue import Queue
from queue import LifoQueue as Stack
from math import sqrt, floor, ceil, log2, log10, pi
from fractions import gcd
from itertools import permutations, combinations
from operator import itemgetter
from functools import cmp_to_key
from bisect import bisect_left


INF=1001001001
__MOD__=(10**9)+7
yn = 'YNeos'
judge = False
cnt = 0
ans = None


def lcm(a, b):
    return (a*b) // gcd(a,b)

def intinput():
    return int(input())

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

def lineinputs(func=intinput):
    datas = []
    while True:
        try:
            datas.append(func())
        except EOFError:
            break
    return datas

def bindex(a,x):
    i = bisect_left(a,x)
    if i != len(a) and a[i] == x:
        return i
    return None

class ModInt():
    def __init__(self, x):
        self.__x = (x % __MOD__)
    def __add__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x + other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x + other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __radd__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x + self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x + self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __sub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x - other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x - other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rsub__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x - self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x - self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __mul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rmul__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__x)%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__x)%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __truediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((self.__x * other.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((self.__x * other.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")
    def __rtruediv__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__((other.__x * self.__modinv())%__MOD__))
        elif type(other) == ModInt:
            return self.__class__((other.__x * self.__modinv())%__MOD__)
        else:
            raise Exception("Not Int or Not ModInt")

    def __pow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(self.__x, other.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(self.__x, other.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")
    def __rpow__(self, other):
        if type(other) == int:
            other = self.__class__(other)
            return int(self.__class__(pow(other.__x, self.__x, __MOD__)))
        elif type(other) == ModInt:
            return self.__class__(pow(other.__x, self.__x, __MOD__))
        else:
            raise Exception("Not Int or Not ModInt")

    def __modinv(self, m=__MOD__):
        a = self.__x
        if a == 0:
            raise ZeroDivisionError()
        if gcd(a, m) != 1:
            raise Exception("%sの逆数は求まりません。" % a)
        b, u, v = m, 1, 0
        while b != 0:
            t = a//b;
            a -= t*b
            a, b = b, a
            u -= t * v
            u, v = v, u
        u %= m
        if u < 0:
            u += m
        return u
    def __int__(self):
        return self.__x
    def __str__(self):
        return str(self.__x)



if __name__ == '__main__':
    D, T, S = mulinputs()

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

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

a = d/s
if a > 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 <= 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 t*s >= d 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(x) for x in input().split()]
print('Yes' if D <= T * S else 'No')

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

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**6)
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

d,t,s = na()

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

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

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

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

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

Solution (Python):
d, t, s = [int(_) for _ in 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):
import sys
from collections import defaultdict, Counter, namedtuple, deque
import itertools
import functools
import bisect
import heapq
import math
import copy


MOD = 10 ** 9 + 7



d, t, s = map(int, input().split())
if t*s >= 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):
A,B,C=list(map(int,input().split()))
if A <= B*C:
   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, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

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

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

if __name__ == '__main__':
    main()

Solution (Python):





def int_mtx(N):
    x = []
    for _ in range(N):
        x.append(list(map(int,input().split())))
    return np.array(x)

def str_mtx(N):
    x = []
    for _ in range(N):
        x.append(list(input()))
    return np.array(x)

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

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

def print_space(l):
    return print(" ".join([str(x) for x in l]))


import numpy as np
import collections as col


D,T,S = int_map()

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

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

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

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


def main():
    t = 1
    while t > 0:
        solve()
        t -= 1


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

Solution (Python):
d, t, s = [int(s) for s in input().split()]
print('Yes' if (d + s - 1) // s <= t else '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().split()))

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

Solution (Python):
dist, time, speed = [int(x) for x in input().split(' ')]

if speed * time >= dist:
    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


inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

d, t, s = inintm()

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

Solution (Python):
d, t, s = list(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/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):
import bisect,collections,copy,itertools,math,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())
def main():
    d,t,s = LI()
    ans = d<=t*s
    print("Yes" if ans else "No")
main()

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

Solution (Python):
import sys

if sys.subversion[0] == "PyPy":
    import io, atexit

    sys.stdout = io.BytesIO()
    atexit.register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))

    sys.stdin = io.BytesIO(sys.stdin.read())
    input = lambda: sys.stdin.readline().rstrip()
RS = raw_input
RA = lambda x=int: map(x, RS().split())
RN = lambda x=int: x(RS())


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





d, t, s = RA()
solve()

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/s<=t else "No")

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


if __name__ == '__main__':
    resolve()

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

from sys import stdin
from sys import setrecursionlimit
setrecursionlimit(10 ** 7)

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

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

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

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

Solution (Python):



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

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

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

Solution (Python):
from collections import Counter
import sys

sys.setrecursionlimit(10 ** 6)

mod = 1000000007
inf = int(1e18)

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


def inverse(a):
    return pow(a, -1, mod)


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




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