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 in Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused_variables, dead_code, clippy::many_single_char_names, unused_imports, unused_macros)]
use std::{
    collections::{HashSet, HashMap, VecDeque},
    io::{stdin, stdout, StdinLock, StdoutLock, BufReader, BufWriter, prelude::*},
    str::FromStr,
};

struct Reader<'a> {
    stdin: BufReader<StdinLock<'a>>
}

trait Integers {
    fn read_int<T: FromStr>(&mut self, cap: usize) -> T;
}

impl<'a> Reader<'a> {
    fn new(stdin: BufReader<StdinLock<'a/*'*/>>) -> Self {
        Self {stdin}
    }

    fn read_str(&mut self, cap: usize) -> String {
        let mut s = String::with_capacity(cap);
        self.stdin.read_line(&mut s).unwrap();

        if s.ends_with('\n') {
            s.pop();
            if s.ends_with('\r') {
                s.pop();
            }
        }
        s
    }

    fn read_vec_u8(&mut self, cap: usize) -> Vec<u8> {
        let mut v = Vec::with_capacity(cap);
        self.stdin.read_exact(&mut v[..]).unwrap();

        v
    }
}

impl<'a> Integers for Reader<'a> {
    fn read_int<T: FromStr>(&mut self, cap: usize) -> T {
        match self.read_str(cap).parse::<T>() {
            Ok(n) => n,
            _ => panic!()
        }
    }
}


const M: usize = 1_000_000;

fn main() {
    let stdin = stdin();
    let stdout = stdout();
    
    solve(&mut Reader::new(BufReader::with_capacity(M, stdin.lock())), &mut BufWriter::with_capacity(M, stdout.lock()));
}

fn solve(r: &mut Reader, w: &mut BufWriter<StdoutLock>) {
    let input = r.read_str(20);
    let mut it = input.split(' ').map(|x| x.parse::<u32>().unwrap());
    let (d, t, s) = (it.next().unwrap(), it.next().unwrap(), it.next().unwrap());

    if t*s < d {
        write!(w, "No").unwrap();
    } else {
        write!(w, "Yes").unwrap();
    }
}