Problem:
Score : 300 points

Problem Statement

Takahashi, who lives on the number line, is now at coordinate X. He will make exactly K moves of distance D in the positive or negative direction.

More specifically, in one move, he can go from coordinate x to x + D or x - D.

He wants to make K moves so that the absolute value of the coordinate of the destination will be the smallest possible.

Find the minimum possible absolute value of the coordinate of the destination.

Constraints

-10^{15} \leq X \leq 10^{15}

1 \leq K \leq 10^{15}

1 \leq D \leq 10^{15}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

X K D

Output

Print the minimum possible absolute value of the coordinate of the destination.

Sample Input 1

6 2 4

Sample Output 1

2

Takahashi is now at coordinate 6. It is optimal to make the following moves:

Move from coordinate 6 to (6 - 4 =) 2.

Move from coordinate 2 to (2 - 4 =) -2.

Here, the absolute value of the coordinate of the destination is 2, and we cannot make it smaller.

Sample Input 2

7 4 3

Sample Output 2

1

Takahashi is now at coordinate 7. It is optimal to make, for example, the following moves:

Move from coordinate 7 to 4.

Move from coordinate 4 to 7.

Move from coordinate 7 to 4.

Move from coordinate 4 to 1.

Here, the absolute value of the coordinate of the destination is 1, and we cannot make it smaller.

Sample Input 3

10 1 2

Sample Output 3

8

Sample Input 4

1000000000000000 1000000000000000 1000000000000000

Sample Output 4

1000000000000000

The answer can be enormous.

Solution in Rust (1.42.0) (judge verdict: Accepted)

fn main() {
    let line = read::<i128>();
    let mut current_pos = line[0];
    let mut move_cnt = line[1];
    let move_distance = line[2];
    // skip
    let skip_cnt = current_pos.abs() / move_distance;
    let skippable_distance = move_distance * skip_cnt;
    if skip_cnt >= move_cnt {
        let tyouka = skip_cnt - move_cnt;
        let actual_distance = skippable_distance - tyouka * move_distance;
        println!("{}", current_pos.abs() - actual_distance);
        return;
    }
    move_cnt -= skip_cnt;
    current_pos -= skippable_distance;

    // move to nearest pos
    let mut prev_pos = current_pos;
    loop {
        if move_cnt == 0 {
            break;
        }
        if current_pos > 0 {
            current_pos = current_pos - move_distance;
        } else {
            current_pos = current_pos + move_distance;
        }
        move_cnt -= 1;
        if current_pos.abs() >= prev_pos.abs() {
            move_cnt += 1;
            current_pos = prev_pos;
            break;
        }
        prev_pos = current_pos;
    }
    if move_cnt == 0 {
        println!("{}", current_pos.abs());
        return;
    }
    // hanpukuyokotobi
    if move_cnt % 2 == 0 {
        println!("{}", current_pos.abs());
    } else {
        let current_pos = if current_pos > 0 {
            current_pos - move_distance
        } else {
            current_pos + move_distance
        };
        println!("{}", current_pos.abs());
    }
}

use std::io::{self, BufRead, Read};
use std::vec::Vec;
fn read<T: std::str::FromStr>() -> Vec<T> {
    let stdin = io::stdin();
    let mut buf = String::new();
    stdin.lock().read_line(&mut buf).unwrap();
    parse_line(&buf)
}

fn read_lines<T: std::str::FromStr>(count: usize) -> Vec<Vec<T>> {
    let stdin = io::stdin();
    let mut stdin = stdin.lock();
    let mut result = Vec::<Vec<T>>::with_capacity(count);
    for _ in 0..count {
        let mut buf = String::new();
        stdin.read_line(&mut buf).unwrap();
        result.push(parse_line(&buf));
    }
    result
}

fn parse_line<T: std::str::FromStr>(string: &str) -> Vec<T> {
    string.trim().split(' ').map(|s| T::from_str(s).ok().unwrap()).collect()
}