Problem:
Score : 100 points

Problem Statement

You are given a positive integer N.
Find the minimum positive integer divisible by both 2 and N.

Constraints

1 \leq N \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N

Output

Print the minimum positive integer divisible by both 2 and N.

Sample Input 1

3

Sample Output 1

6

6 is divisible by both 2 and 3.
Also, there is no positive integer less than 6 that is divisible by both 2 and 3.
Thus, the answer is 6.

Sample Input 2

10

Sample Output 2

10

Sample Input 3

999999999

Sample Output 3

1999999998

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

macro_rules! get {
    ($read:ident, $t:ty) => {
        {
            let mut line: String = String::new();
            $read.read_line(&mut line).unwrap();
            line.trim().parse::<$t>().unwrap()
        }
    };
    ($read:ident, $($t:ty),*) => {
        {
            let mut line: String = String::new();
            $read.read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            (
             $(iter.next().unwrap().parse::<$t>().unwrap(),)*
            )
        }
    };
    ($read:ident, $t:ty; $n:expr) => {
        (0..$n).map(|_|
                get!($read, $t)
                ).collect::<Vec<_>>()
    };
    ($read:ident, $($t:ty),*; $n:expr) => {
        (0..$n).map(|_|
                get!($read, $($t),*)
                ).collect::<Vec<_>>()
    };
    ($read:ident, $t:ty ;;) => {
        {
            let mut line: String = String::new();
            $read.read_line(&mut line).unwrap();
            line.split_whitespace()
                .map(|t| t.parse::<$t>().unwrap())
                .collect::<Vec<_>>()
        }
    };
    ($read:ident, $t:ty ;; $n:expr) => {
        (0..$n).map(|_| get!($read, $t ;;)).collect::<Vec<_>>()
    };
}

fn main() {
    let read = std::io::stdin();
    let write = std::io::stdout();
    solve(read.lock(), write.lock());
}

fn solve<R: std::io::BufRead, W: std::io::Write>(mut read: R, mut write: W) {
    let n = get!(read, u64);
    let result = if n % 2 == 0 { n } else { n * 2 };
    println!("{}", result);
}