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 C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection.Emit;
using System.Runtime.Remoting.Proxies;
using System.Text;
using static System.Console;
using static System.Math;
using static Ex;
class Simple {
    public static void Main(string[] args) => new Simple().Stream();
    IO io = new IO();
    private void Stream() {
        //var exStdIn = new System.IO.StreamReader("stdin.txt");
        //SetIn(exStdIn);
        Solve();
        //Test();
        io.Flush();
    }

    void Solve() {
        var N = io.Int;
        var ans = N.Odd() ? N * 2 : N;
        io.o(ans);
    }
    void Test() {
        
    }
}

class IO {    
    #region INPUT
    private const int Size = 1 << 12;
    private readonly Stream _stream = Console.OpenStandardInput();
    private readonly byte[] _buffer = new byte[Size];
    private int _ptr = 0, _buffLen = 0;
    private bool   HasNextByte() { if(_ptr < _buffLen) return true; _ptr = 0; _buffLen = _stream.Read(_buffer, 0, Size); return _buffLen > 0; }
    private byte ReadByte() {
        if(HasNextByte())
            return _buffer[_ptr++];
        else 
            throw new EndOfStreamException();
    }
    private bool   IsAscii(int c) => '!' <= c && c <= '~';
    private void   SkipNonAscii() { while(HasNextByte()&&!IsAscii(_buffer[_ptr])) _ptr++; }
    private bool   HasNext(){ SkipNonAscii();return HasNextByte(); }
    private char   NextChar() { byte b = 0; do b = ReadByte(); while(!IsAscii(b));return (char)b;}
    private string Next() { var sb = new StringBuilder(); for(var b = NextChar(); IsAscii(b); b = (char)ReadByte()) sb.Append(b); return sb.ToString();}    
    private void   Read<T>(out T v) => v = SuitType<T>(Next());
    private T      ConvertType<T, TU>(TU v) => (T)Convert.ChangeType(v, typeof(T));
    private bool   TypeEqual<T, TU>()    => typeof(T) == typeof(TU);
    private T      SuitType<T>(string s) {
        if(TypeEqual <T, int>   ()) ConvertType <T, int>   (int.Parse(s));
        if(TypeEqual <T, long>  ()) ConvertType <T, long>  (long.Parse(s));
        if(TypeEqual <T, double>()) ConvertType <T, double>(double.Parse(s));
        if(TypeEqual <T, char>  ()) ConvertType <T, char>  (char.Parse(s));
        return ConvertType<T, string>(s);        
    }   
    private T     i<T>()   =>SuitType<T>(String);
    public string String => Next();
    public char   Char   => NextChar();
    public int    Int    => int.Parse(Next());
    public long   Long   => long.Parse(Next());
    public double Double => double.Parse(Next());
    public void   i<T>(out T v) => Read(out v);
    public void   i<T, TU>(out T t, out TU u) { i(out t); i(out u);}
    public void   i<T, TU, TV>(out T t, out TU u, out TV v) { i(out t, out u); i(out v);}
    public void   i<T, TU, TV, TW>(out T t, out TU u, out TV v, out TW w) { i(out t, out u, out v); i(out w);}
    public void   i<T, TU, TV, TW, TX>(out T t, out TU u, out TV v, out TW w, out TX x) { i(out t, out u, out v, out w);i(out x);}
    public void   ini<T>(out T[] a, int n) { a = new T[n]; for (int i = 0; i < n; ++i) a[i] = i<T>();}
    public void   ini<T, TU>(out T[] a, out TU[] b, int n) { a = new T[n]; b = new TU[n]; for (int i = 0; i < n; ++i) { a[i] = i<T>(); b[i] = i<TU>(); }}
    public void   ini<T, TU, TV>(out T[] a, out TU[] b, out TV[] c, int n) { a = new T[n]; b = new TU[n]; c = new TV[n]; for (int i = 0; i < n; ++i) { a[i] = i<T>(); b[i] = i<TU>(); c[i] = i<TV>();}}
    public void   ini<T>(out T[,] a, int h, int w) { a = new T[h, w]; for (int i = 0; i < h; ++i) for (int j = 0; j < w; ++j) a[i, j] = i<T>();}
    #endregion
    #region OUTPUT
    private readonly StreamWriter _sw = new StreamWriter(Console.OpenStandardOutput()) {
#if DEBUG
        AutoFlush = true
#else
        AutoFlush = false
#endif
    };
    public void  Flush()=> Console.Out.Flush();
    private void Out<T>    (T v) => Console.Write(v);
    private void OutLine<T>(T v) => Console.WriteLine(v);
    public void  o()       => OutLine("");
    public void  o<T>(T v) => OutLine(v);
    public void  o<T>(params T[] a)  => Array.ForEach(a, OutLine);
    public void  o<T>(T[,] a) { int a0 = a.GetLength(0), a1 = a.GetLength(1); for (int i = 0; i < a0; ++i) { for (int j = 0; j < a1 - 1; ++j) Out(a[i, j] + " "); OutLine(a[i, a1 - 1]); } }
    public void ol<T>(params T[] a) => OutLine(string.Join(" ", a));
    public void YN(bool f) => OutLine(f ? "YES" : "NO");
    public void Yn(bool f) => OutLine(f ? "Yes" : "No");
    public void yn(bool f) => OutLine(f ? "yes" : "no");        
    #endregion
    public IO() {                        
        Console.SetOut(_sw);            
    }        
}
static class Ex {
    public static void REP(int a, Action <int> act) => FOR(0, a, act);    
    public static void FOR(int a, int b, Action <int> act) { for(int i = a; i < b; ++i) act(i);}
    public static void REPEQ(int a, Action <int> act) => FOR(0, a + 1, act);
    public static void FOREQ(int a, int b, Action <int> act) => FOR(a, b + 1, act);
    public static T    MIN<T>(params T[] a) => a.Min();
    public static T    MAX<T>(params T[] a) => a.Max();
}
static class NumEx {
    public static string toString(this double d) => d.ToString("R");
    public static string Pad0<T>(this T s, int n) => s.ToString().PadLeft(n, '0');
    /// <summary>
    /// 
    /// </summary>
    /// <param name="v"></param>
    /// <param name="n"></param>
    /// <returns></returns>
    public static string RoundOff(this double v, int n) => Math.Round(v, n - 1, MidpointRounding.AwayFromZero).toString();
    public static string RoundUp(this double v) => Math.Ceiling(v).toString();
    public static string RoundDown(this double v) => Math.Floor(v).toString();
    public static bool Odd(this int v) => (v & 1) != 0;
    public static bool Odd(this long v) => (v & 1) != 0;
}