Problem:
Score : 100 points

Problem Statement

You have three tasks, all of which need to be completed.

First, you can complete any one task at cost 0.

Then, just after completing the i-th task, you can complete the j-th task at cost |A_j - A_i|.

Here, |x| denotes the absolute value of x.

Find the minimum total cost required to complete all the task.

Constraints

All values in input are integers.

1 \leq A_1, A_2, A_3 \leq 100

Input

Input is given from Standard Input in the following format:

A_1 A_2 A_3

Output

Print the minimum total cost required to complete all the task.

Sample Input 1

1 6 3

Sample Output 1

5

When the tasks are completed in the following order, the total cost will be 5, which is the minimum:

Complete the first task at cost 0.

Complete the third task at cost 2.

Complete the second task at cost 3.

Sample Input 2

11 5 5

Sample Output 2

6

Sample Input 3

100 100 100

Sample Output 3

0

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

struct Scanner<'a> {
    _buf: &'a str,
    iter: ::std::str::SplitWhitespace<'a>,
}

impl<'a> Scanner<'a> {
    fn new(buf: &'a str) -> Self {
        Scanner {
            _buf: buf,
            iter: buf.split_whitespace(),
        }
    }

    fn next<T>(&mut self) -> T
        where T: ::std::str::FromStr,
              T::Err: ::std::fmt::Debug,
    {
        self.iter.next().unwrap().parse().unwrap()
    }
}

fn read() -> String {
    use ::std::io::Read;
    let mut res = String::new();
    ::std::io::stdin().read_to_string(&mut res).unwrap();
    res
}

fn main() {
    let _input = read();
    let mut sc = Scanner::new(&_input);

    let a: [i64; 3] = [sc.next(), sc.next(), sc.next()];

    let ans = a.iter().max().unwrap() - a.iter().min().unwrap();

    println!("{}", ans);
}