Problem:
Score : 400 points

Problem Statement

Given are integers A, B, and N.

Find the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non-negative integer x not greater than N.

Here floor(t) denotes the greatest integer not greater than the real number t.

Constraints

1 ≤ A ≤ 10^{6}

1 ≤ B ≤ 10^{12}

1 ≤ N ≤ 10^{12}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B N

Output

Print the maximum possible value of floor(Ax/B) - A × floor(x/B) for a non-negative integer x not greater than N, as an integer.

Sample Input 1

5 7 4

Sample Output 1

2

When x=3, floor(Ax/B)-A×floor(x/B) = floor(15/7) - 5×floor(3/7) = 2. This is the maximum value possible.

Sample Input 2

11 10 9

Sample Output 2

9

Solution in Rust (1.42.0) (judge verdict: Runtime Error)

struct ParsedData {
    a: f32,
    b: f32,
    n: f32,
}

fn main() {
    let result = max_floor(parser(""));
    println!("{}", result);
}

fn parser(data: &str) -> ParsedData {
    let mut iter = data.split_whitespace();
    let a = iter.next().unwrap().parse::<f32>().unwrap();
    let b = iter.next().unwrap().parse::<f32>().unwrap();
    let n = iter.next().unwrap().parse::<f32>().unwrap();
    ParsedData{a: a, b: b, n: n}
}

fn max_floor(data: ParsedData) -> i32 {
    let ParsedData {a, b, n} = data;
    if b - 1.0 < n {
        return (((a * (b - 1.0)).floor() / b) - (a * ((b - 1.0) / b).floor())) as i32;
    }
    (((a * n) / b).floor() - (a * (n / b).floor())) as i32
}

#[test]
fn qa() {
    let answer = 2;
    let result = max_floor(parser("5 7 4"));
    if result != answer {
        panic!("not be result : {} expect {}", result, answer)
    }
}

#[test]
fn qb() {
    let answer = 9;
    let result = max_floor(parser("11 10 9"));
    if result != answer {
        panic!("not be result : {} expect {}", result, answer)
    }
}