Problem:
Score : 100 points

Problem Statement

A biscuit making machine produces B biscuits at the following moments: A seconds, 2A seconds, 3A seconds and each subsequent multiple of A seconds after activation.

Find the total number of biscuits produced within T + 0.5 seconds after activation.

Constraints

All values in input are integers.

1 \leq A, B, T \leq 20

Input

Input is given from Standard Input in the following format:

A B T

Output

Print the total number of biscuits produced within T + 0.5 seconds after activation.

Sample Input 1

3 5 7

Sample Output 1

10

Five biscuits will be produced three seconds after activation.

Another five biscuits will be produced six seconds after activation.

Thus, a total of ten biscuits will be produced within 7.5 seconds after activation.

Sample Input 2

3 2 9

Sample Output 2

6

Sample Input 3

20 20 19

Sample Output 3

0

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::stdin;
use std::io::Error;
use std::io::ErrorKind;
use std::io::Read;

#[derive(Debug)]
struct Input {
    a: u8,
    b: u8,
    t: u8,
}

fn handle_input(input_str: String) -> Result<Input, Error> {
    let mut iter = input_str.split_whitespace();
    let input = match (iter.next(), iter.next(), iter.next()) {
        (Some(a_str), Some(b_str), Some(t_str)) => {
            let (a, b, t): (u8, u8, u8) = match (a_str.parse(), b_str.parse(), t_str.parse()) {
                (Ok(a), Ok(b), Ok(t)) => (a, b, t),
                _ => return Err(Error::new(ErrorKind::InvalidInput, "")),
            };
            Input { a: a, b: b, t: t }
        }
        _ => return Err(Error::new(ErrorKind::InvalidInput, "")),
    };
    Ok(input)
}

fn handle_output(input: Input) -> Result<String, Error> {
    Ok(format!("{}", input.t / input.a * input.b))
}

fn main() {
    let mut input_str = String::new();
    let stdin = stdin();
    stdin.lock().read_to_string(&mut input_str).unwrap();
    let input = handle_input(input_str).unwrap();
    let output = handle_output(input).unwrap();
    println!("{}", output);
}