Problem:
Score : 200 points

Problem Statement

Given are integers a,b,c and d.
If x and y are integers and a \leq x \leq b and c\leq y \leq d hold, what is the maximum possible value of x \times y?

Constraints

-10^9 \leq a \leq b \leq 10^9

-10^9 \leq c \leq d \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

a b c d

Output

Print the answer.

Sample Input 1

1 2 1 1

Sample Output 1

2

If x = 1 and y = 1 then x \times y = 1.
If x = 2 and y = 1 then x \times y = 2.
Therefore, the answer is 2.

Sample Input 2

3 5 -4 -2

Sample Output 2

-6

The answer can be negative.

Sample Input 3

-1000000000 0 -1000000000 0

Sample Output 3

1000000000000000000

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

use std::io::*;
use std::str::*;
use std::cmp;

fn read<T: FromStr>(s: &mut StdinLock) -> T {
    let s = s.by_ref().bytes().map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>();
    s.parse::<T>().ok().unwrap()
}


fn main() {
    let s = stdin();
    let mut s = s.lock();
    let s = &mut s;

	let a = read::<i64>(s);
	let b = read::<i64>(s);
	let c = read::<i64>(s);
	let d = read::<i64>(s);

	let minab: i64 = cmp::min(a,b);
	let maxab: i64 = cmp::max(a,b);
	let mincd: i64 = cmp::min(c,d);
	let maxcd: i64 = cmp::max(c,d);

	let mut maxv = std::i64::MIN;

	if minab*mincd > maxv { maxv = minab*mincd; }
	if minab*maxcd > maxv { maxv = minab*maxcd; }
	if maxab*mincd > maxv { maxv = maxab*mincd; }
	if maxab*maxcd > maxv { maxv = maxab*maxcd; }


	println!("{}", maxv);


}