Problem:
Score : 100 points

Problem Statement

We have two integers: A and B.

Print the largest number among A + B, A - B, and A \times B.

Constraints

All values in input are integers.

-100 \leq A,\ B \leq 100

Input

Input is given from Standard Input in the following format:

A B

Output

Print the largest number among A + B, A - B, and A \times B.

Sample Input 1

-13 3

Sample Output 1

-10

The largest number among A + B = -10, A - B = -16, and A \times B = -39 is -10.

Sample Input 2

1 -33

Sample Output 2

34

The largest number among A + B = -32, A - B = 34, and A \times B = -33 is 34.

Sample Input 3

13 3

Sample Output 3

39

The largest number among A + B = 16, A - B = 10, and A \times B = 39 is 39.

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

pub struct Scanner{
     line : Vec<String> ,
     idx : usize
}

impl  Scanner{
    #[allow(dead_code)]
    fn new() -> Scanner{
        return Scanner{ line: vec![], idx : 0}
    }
    #[allow(dead_code)]
    fn next<T: std::str::FromStr> (&mut self) -> T{
        if self.idx == self.line.len() {
            let mut buffer = String::new();
            std::io::stdin().read_line(&mut buffer).ok();

            let a : Vec<&str>  = buffer.trim().split(' ').collect();
            self.line = a.iter().map(|&s| String::from(s)).collect();
            self.idx = 0;
        }
        let ret : T = self.line[self.idx].parse::<T>().ok().expect("Parse error.");
        self.idx += 1;
        ret
    }
    #[allow(dead_code)]
    fn read_vec<T: std::str::FromStr>  (&mut self, n: usize) -> Vec<T>{
        let mut v : Vec<T>= Vec::with_capacity(n);
        for _i in 0..n {
            v.push(self.next());
        }
        v
    }
}


fn main() {
    let mut scan = Scanner::new();
    let a:i32  = scan.next();
    let b:i32  = scan.next();

    let ans = std::cmp::max(a + b,  std::cmp::max(a - b, a * b));

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