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 (Python):
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
  
n=int(input())
print(lcm(2,n))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N*2)

Solution (Python):
import itertools
import fractions
def main():
  n = int(input())
  a = fractions.gcd(2,n)
  lcm = 2 * n//a
  print(lcm)
if __name__ == '__main__':
  main()

Solution (Python):
n=int(input())
if n%2==0:
        print(n)
else:
        print(2*n)

Solution (Python):
n = int(input())

if n%2 == 0:
  print(n)
else:
  print(2*n)

Solution (Python):
def koubaisu(N,M):
    NM = N*M
    if M>N:
        N,M = M,N
    while(N%M!=0):
        Temp = N
        N = M
        M = Temp%M
    return NM//M
N = int(input())
print(koubaisu(N,2))

Solution (Python):
n = int(input())
if n % 2 != 0:
    print(n*2)
else:
    print(n)

Solution (Python):
N = int(input())
if N%2:
  print(2*N)
  quit()

print(N)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n * 2)

Solution (Python):
import sys

n = int(sys.stdin.readline().rstrip())

def main():
    ans = n
    if n & 1: ans *= 2
    print(ans)

if __name__ ==  '__main__':
    main()

Solution (Python):
N = int(input())
ans = N if N%2==0 else N*2
print(ans)

Solution (Python):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    
    if a[0] %2 ==0:
        print(a[0])
    else:
        print(a[0]*2)

Solution (Python):
def Multiple(n):

    return n if n % 2 == 0 else n * 2

def main():
    n = int(input())
    print(Multiple(n))

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
print(n if n % 2 == 0 else 2 * n)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(2*N)

Solution (Python):
n = int(input())
if n%2!=0: n*=2
print(n)

Solution (Python):
n = int(input())
if n&1:
  print(2*n)
else:
  print(n)

Solution (Python):
N = int(input())

if N % 2 ==0 :
	answer = N
else:
	answer = N * 2
print(answer)

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):

N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):


def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate
    
    from bisect import bisect_left,bisect_right
    import heapq
    from math import floor, ceil
    

    
    

    N = int(input())
    if N%2==0:
        print(N)
    else:
        print(N*2)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

if n%2 :
  print(n*2)
else:
  print(n)

Solution (Python):
n=int(input())
if n%2==0:print(n)
else:print(n*2)

Solution (Python):
import fractions
n = int(input())

ans = 2 * n // fractions.gcd(2, n)
print(ans)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
n = int(input())
if n%2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
N = int(input())

if N%2 == 0:
  print(N)
else:
  print(N*2)

Solution (Python):
import fractions
a = int(input())
num = fractions.gcd(2,a)
print(a*2//num)

Solution (Python):
N=int(input())
if N%2==0 and N>=2:
    print(N)
else :
    print(2*N)

Solution (Python):
N = int(input())

if N % 2 == 0:
  print(N)
  
else:
  print(N*2)

Solution (Python):


def solve():
    N = int(input())

    if N % 2 == 0:
        print(N)
    else:
        print(N*2)



if __name__ == "__main__":
    solve()

Solution (Python):
N=int(input())
print(N*2 if N%2!=0 else N)

Solution (Python):
N =int(input())
l = N * 2
if N % 2 == 0:
    print(N)
else:
    print(N*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n * 2)

Solution (Python):
N = int(input())
if N%2==0:
    print(N)
else:
    print(N*2)

Solution (Python):
N = int(input())
print(N * 2 if N % 2 else N)

Solution (Python):
N=int(input());print(N%2*N*2 or N)

Solution (Python):
N=int(input())
if N%2==0:
  print(int(N))
else:
  print(2*int(N))

Solution (Python):

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a



def lcm(a, b):
    return a * b // gcd(a, b)


N = int(input())
print(lcm(2, N))

Solution (Python):
n = int(input())

if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
a = int(input())

if a % 2 == 0:
    print(a)
else:
    print(2*a)

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(2*n)

Solution (Python):
n = int(input())
print(n if n%2==0 else n*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(2*n)

Solution (Python):
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    N = int(input())
    if N % 2 == 0:
        print(N)
    else:
        print(N * 2)

if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())

if N%2==0:
  print(N)
else:
  print(2*N)

Solution (Python):
n = int(input())

if n % 2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
n = int(input())

if n % 2 == 1:
  print(n * 2)
else:
  print(n)

Solution (Python):
def main():
    n = int(input())
    if n % 2 == 0:
        ans = n
    else:
        ans = n * 2
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
print(N*2 if N%2 else N)

Solution (Python):

a = int (input())
print(a) if a % 2 == 0 else print(a * 2)

Solution (Python):
n = int(input())
print(n*2) if n%2 else print(n)

Solution (Python):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    N = int(sys.stdin.buffer.readline().rstrip())
    print(N if N%2 == 0 else N*2)


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input());print(n if n%2==0 else n*2)

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(2 * n)

Solution (Python):
n=int(input())
if n%2:
  print(n*2)
else:
  print(n)

Solution (Python):
N = int(input())
if N == 1:
    print(2)
elif N %2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
n=int(input())
if(n%2==1):n*=2
print(n)

Solution (Python):
n=int(input())
if n%2==0:
        print(n)
else:
        print(n*2)

Solution (Python):
N=int(input())
if N%2==0:
  print(N)
else:
  print(N*2)

Solution (Python):
N = int(input())

if N % 2 == 0:
    ans = N
else:
    ans = 2 * N

print(ans)

Solution (Python):
n = int(input())
print(n if n%2==0 else n*2)

Solution (Python):
N = int(input())

if N%2:
    print(2*N)
else:
    print(N)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(2 * n)

Solution (Python):
n=int(input())
print(2*n if n%2 else n)

Solution (Python):
a = int(input())
if a %2==0:
  print(a)
else:
  print(a*2)

Solution (Python):

n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
n=int(input())

if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(N * 2)

Solution (Python):
N = int(input())
if N%2 ==0:
    print(N)
else:
    print(N*2)

Solution (Python):


import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

def gcd(m, n):
    if n == 0:
        return m
    else:
        return gcd(n, m % n)

def lcm(m, n):
    return m * n // gcd(m, n)

N = ni()
print(lcm(2, N))

Solution (Python):
a=int(input())
print(a if (a%2==0) else a*2)

Solution (Python):
n = int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
N = int(input())

for i in range(N,N*2+1,N):
  if i % 2 == 0 and i % N == 0:
    print(i)
    break

Solution (Python):
a = int(input())
if a % 2 == 1:
    print(a*2)
else:
    print(a)

Solution (Python):
a=int(input())
if a % 2 ==1:
	print(a*2)
else:
	print(a)

Solution (Python):
n = int(input())
print(n) if n%2 == 0 else print(n*2)

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
N=int(input())
if N%2==0:
    print(N)
else:
    print(N*2)

Solution (Python):

n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(2*n)

Solution (Python):
N = int(input())
 
if N % 2 == 0:
  print(int(N))
else:
  print(int(2*N))

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n)
else:
    print(2*n)

Solution (Python):
N = int(input())
if N%2 == 0:
  print(N)
  
else:
  print(N*2)

Solution (Python):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

def main():
    n = int(input())
    
    if n % 2 == 0:
        print(n)
    else:
        print(n*2)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
if n%2==0:print(n)
else:print(n*2)

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
a = int(input())
print(a) if a%2 ==0 else print(a*2)

Solution (Python):
N=int(input())
print(N if N%2==0 else N*2)

Solution (Python):
n=int(input())
if n%2 == 0:
    print(n)
else:
    print(2*n)

Solution (Python):
N=int(input())
if N%2==0:
    print(N)
else:
    print(2*N)

Solution (Python):
N = int(input())

if N%2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
import fractions

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
  
N = int(input())

print(lcm(2, N))

Solution (Python):
n = int(input())
if n%2==0:
    print(n)
else :
    print(n*2)

Solution (Python):
n = int(input())
if n%2:
    print(n*2)
else:
    print(n)

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n=int(input())
if(n%2==0):
    print(n)
else:
    print(n*2)

Solution (Python):

N = int(input())

if N % 2 == 0:
    ans = N
else:
    ans = N * 2
print(ans)

Solution (Python):
n=int(input())

if n%2==1:
    print(n*2)
else:
    print(n)

Solution (Python):
n = int(input())

print(2*n if n % 2 == 1 else n)

Solution (Python):
u = int(input())
if u % 2 == 1:
  print (u*2)
else:
  print (u)

Solution (Python):

s = int(input())
if s % 2 == 0:
    print(int(s))
else:
    print(int(s*2))

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n * 2)

Solution (Python):
import fractions

n = int(input())


print((n*2)// fractions.gcd(n,2))

Solution (Python):
n = int(input())


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a


def lcm(a, b):
    return a * b // gcd (a, b)

print(lcm(2, n))

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
n = int(input())

if n % 2:
    print(2*n)
else:
    print(n)

Solution (Python):
n=int(input())

if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(2*n)

Solution (Python):


N = int(input().strip())

if N % 2 == 0:
  print(N)
else:
  print(2*N)

Solution (Python):
N=int(input())
if N%2==0:
  print(N)
else:
  print(N*2)

Solution (Python):
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a%b)

n = int(input())
print(2*n//gcd(2, n))

Solution (Python):
n = int(input())
print(n if n%2==0 else n*2)

Solution (Python):
N = int(input())
print(N if N%2 == 0 else 2 * N)

Solution (Python):
n = int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())


if n % 2:
  print(n*2)
else:
  print(n)

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
	print(n * 2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n * 2)

Solution (Python):
N = int(input())

if N % 2 == 0:
  print(N)
else:
  print(N*2)

Solution (Python):
def gcd(a, b):   
    if b == 0:
        return a
    else:
        return gcd(b, a%b)
    
def lcm(a, b):   
    return a*b // gcd(a, b)

n = int(input())
print(lcm(2, n))

Solution (Python):
from fractions import gcd

N=int(input())

print(int(2 * N / gcd(2, N)))

Solution (Python):
n = int(input())
if n % 2:
  print(n * 2)
else:
  print(n)

Solution (Python):
N = int(input())
if N % 2 ==0:
  print(N)
else:
  print(N*2)

Solution (Python):
N=int(input())
print(N if N%2==0 else N*2)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(2 * N)

Solution (Python):
N = input()
N = int(N)

if (N % 2 == 0):
	print(N)
else:
	print(N*2)

Solution (Python):
N = int(input())

if N % 2 == 0:
  print(N)
else:
  print(N*2)

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(2*n)

Solution (Python):
N = int(input())

if N % 2 != 0:
    print(N * 2)
else:
    print(N)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):
n=int(input())
print(n if n%2==0 else n*2)

Solution (Python):
N = int(input())

if N%2==0:
  print(N)
else:
  print(2*N)

Solution (Python):
n=int(input())
print(n) if n%2==0 else print(n*2)

Solution (Python):
import fractions
a = int(input())
print((a * 2) // fractions.gcd(a, 2))

Solution (Python):
n=int(input())
if n%2==0:print(n)
else:print(2*n)

Solution (Python):
import fractions

N=int(input())
print(N*2//fractions.gcd(2,N))

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(2 * N)

Solution (Python):
def gcd(x, y):
    while y != 0:
        x, y = y, x % y
    return x


def lcm(x,y):
    return x * y // gcd(x, y)


N = int(input())
print(lcm(2, N))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):

N=int(input())
print(N if N%2==0 else N*2)

Solution (Python):
N = int(input())
if N%2==0:
    print(N)
else:
    print(2*N)

Solution (Python):
n = int(input())
if n % 2:
    print(2 * n)
else:
    print(n)

Solution (Python):
N = int(input())

if N % 2 == 1:
  print(N * 2)
else:
  print(N)

Solution (Python):
k=int(input())
if k%2==0:
  print(k)
else:
  print(2*k)

Solution (Python):
N=int(input())
if N%2==0:
  print(N)
else:
  print(N*2)

Solution (Python):
n = int(input())
if n%2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
N=input()
if N%2==0:
    print N
else:
    print N*2

Solution (Python):
N = int(input())

if N%2 == 0 :
    print(N)
else :
    print(N*2)

Solution (Python):
n = int(input())
if(n %2==1):
  n *= 2
print(n)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(N * 2)

Solution (Python):
def gcd(x, y):
    if y == 0:
        return x
    return gcd(y, x%y)

def lcm(x, y):
    if x < y:
        z = x
        x = y
        y = z
    return x / gcd(x, y) * y

print(int(lcm(int(input()), 2)))

Solution (Python):
s = int(input())
print(s if s%2 == 0 else s*2)

Solution (Python):
N=int(input())
print(N if N%2==0 else N*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(2 * n)

Solution (Python):
n = int(input())
if n%2==0: print(n)
else: print(n*2)

Solution (Python):
R=int(input())
if R%2==0:
    print(R)
else:
    print(R*2)

Solution (Python):
n = int(input())
if(n % 2 == 0):
    print(n)
elif(n % 2 != 0):
    print(n*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(2*n)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(2*N)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
N = int(input())
print(N*2) if N % 2 == 1 else print(N)

Solution (Python):
from fractions import gcd

n=int(input())
g=gcd(2,n)
print(2*n//g)

Solution (Python):
def main():
    number = int(input())
    if number % 2:
        print(number * 2)
    else:
        print(number)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(2*n)

Solution (Python):
n=int(input())
if n%2==0:print(n)
else:print(2*n)

Solution (Python):
N = int(input())
print(N if N % 2 == 0 else N*2)

Solution (Python):
N = int(input())

if N%2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
n = int(input())
print(n if n % 2 == 0 else n * 2)

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(2 * n)

Solution (Python):
N = int(input())

if N%2 !=0:
  print(N * 2)
else:
  print(N)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(2 * N)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else :
    print(2 * N)

Solution (Python):
N = int(input())

def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a


def lcm(a,b):
    return a*b//gcd(a,b)

print(lcm(2,N))

Solution (Python):
n = int(input())
print([n,2*n][n%2==1])

Solution (Python):




def main():
    N = int(input())
    print(N if N % 2 == 0 else N * 2)


if __name__ == "__main__":
    main()

Solution (Python):
N=int(input())
if N%2==0:
  print(N)
else:
  print(2*N)

Solution (Python):
n = int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
import fractions
n = int(input())
print(int(2 * n / fractions.gcd(2, n)))

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(n+n)

Solution (Python):
N=int(input())
if N%2==0:
    print(N)
else:
    print(N*2)

Solution (Python):
n = int(input())
print(n) if n % 2 == 0 else print(n*2)

Solution (Python):
from fractions import gcd

n = int(input())

print(2*n//gcd(2, n))

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n=int(input())
if n%2!=0:
  n*=2
print(n)

Solution (Python):
n = int(input())

if n % 2 == 0: print(n)
else: print(2*n)

Solution (Python):
N = int(input())

print(N if N % 2 == 0 else N*2)

Solution (Python):
N = int(input())
if N%2==0:
    print(N)
else:
    print(2*N)

Solution (Python):
n=int(input())
print(n*(1+n%2))

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
n=int(input())

if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
N=int(input())
if N%2==0:
  res=N
else:
  res=N*2
print(res)

Solution (Python):
n = int(input())
if n%2 == 0:
	print (n)
else:
	print (n*2)

Solution (Python):
import sys
s=int(input())
if s%2==1:
	s=2*s
print(s)

Solution (Python):
N=int(input())

if (N%2==0):
    print(N)
else:
    print(N*2)

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())
print(2 * n if n % 2 else n)

Solution (Python):
n=int(input())
print(n if n%2==0 else n*2)

Solution (Python):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(readline().split()[0])
print(2*n if n % 2 else n)

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(2*n)

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(2*n)

Solution (Python):
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N = int(readline())
print(2 * N if N % 2 == 1 else N)

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
x = int(input())
 
if x%2 == 0:
  print(x)
else:
  print(x*2)

Solution (Python):
n=int(input())
if n%2==0:
	print(n)
else:
	print(2*n)

Solution (Python):
n = int(input())
print(n if n%2==0 else 2*n)

Solution (Python):
N=int(input())
if N%2==0:
  print(N)
else:
  print(2*N)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
n = int(input())

if n % 2 == 0:
  print(n)
else:
  print(2*n)

Solution (Python):
from fractions import gcd

n = int(input().strip())
print((2 * n) // gcd(2, n))

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):
N=int(input())
if N%2==0:
    print(N)
else:
    print(2*N)

Solution (Python):
N=int(input())

if N%2==0:
  print(N)
else:
  print(2*N)

Solution (Python):
N = int(input())
print(N * (N % 2 + 1))

Solution (Python):


from fractions import gcd

def lcm(x, y):
    return (x * y) // gcd(x, y)

def main():
    from sys import stdin, setrecursionlimit
    setrecursionlimit(10**6)
    r = stdin.readline()[:-1]
    
    
    

    a = int(r)
    print(lcm(2,a))
if __name__ == '__main__':
    main()

Solution (Python):
a = int(input())
print(a if a%2==0 else a*2)

Solution (Python):
a = int(input()); print(a + a % 2 * a)

Solution (Python):
N = int(input())
print(N) if N % 2 == 0 else print(N * 2)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(2 * N)

Solution (Python):
n = int(input())
if n % 2 == 0:
  print(n)
else:
  print(2 * n)

Solution (Python):
a = int(input())
if a%2 == 0:
  print(a)
else:
  print(2*a)

Solution (Python):
def gcd(a, b):
  while b:
    a, b = b, a%b
  return a
 
def lcm(a, b):
  return a*b // gcd(a, b)

N = int(input())
ans = lcm(2, N)
print(ans)

Solution (Python):
import bisect
import cmath
import heapq
import itertools
import math
import operator
import os
import random
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


n = int(sys.stdin.buffer.readline())
if n & 1:
    print(n * 2)
else:
    print(n)

Solution (Python):
import math
import queue
import bisect
import heapq
import time
import itertools

mod = int(1e9+7)

def swap(a,b):
    return (b,a)

def my_round(a,dig=0):
    p = 10 ** dig
    return (a * p * 2 + 1) // 2 / p

def gcd(a,b): 
    if (a<b):
        a,b = swap(a,b)
    if (b==0):
        return a
    else:
        return gcd(b,a%b)

def lcm(a,b): 
    return a/gcd(a,b)*b

def divisors(a): 
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def is_prime(a): 
    if a<2:
        return False
    elif a==2:
        return True
    elif a%2==0:
        return False
    sqrt_num = int(a**0.5)
    for i in range(3,sqrt_num+1,2):
        if a%i==0:
            return False
    return True

def prime_num(a): 
    pn = [2]
    for i in range(3,int(a**0.5),2):
        prime = True
        for j in pn:
            if i%j==0:
                prime = False
                break
        if prime:
            pn.append(i)
    return pn

def prime_fact(a): 
    sqrt = math.sqrt(a)
    res = []
    i = 2
    if is_prime(a):
        res.append(a)
    else:
        while a!=1:
            while a%i==0:
                res.append(i)
                a //= i
            i += 1
    return res

def main():
    n = int(input())
    if n%2==0:
        print(n)
    else:
        print(n * 2)
    return

if __name__=='__main__':
    main()

Solution (Python):
import fractions
N = int(input())

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(2, N))

Solution (Python):
n = int(input())

if n % 2 == 1:
    print(2 * n)
else:
    print(n)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
import fractions
n = int(input())
print(int((2*n)/fractions.gcd(2,n)))

Solution (Python):
n = int(input())

if n % 2 == 0:
  print(n)
else:
  print(2 * n)

Solution (Python):
n = int(input())
if (n % 2) == 0:
  print(n)
else:
  print(n * 2)

Solution (Python):
n = int(input())
print(n if n%2==0 else n*2)

Solution (Python):
N = int(input())
if N%2 == 0:
  r = N
else:
  r = N * 2
print(int(r))

Solution (Python):
n = int(input())

for i in range(1, 100000000, 1):
    if(n*i % 2==0):
        print(n*i)
        break

Solution (Python):
n = int(input())
if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
x = int(input())

if x % 2 == 0:
  print(x)
else:
  print(2 * x)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):
a=int(input())
if a%2==0:
    print(a)
else:
    print(a*2)

Solution (Python):
a = int(input())

if a % 2 == 0:
	print(a)
else:
	print(2*a)

Solution (Python):
N = int(input())
print(N*2 if N&1 else N)

Solution (Python):
x = int(input())
if x%2 == 0:
    print(x)
else:
    print(x*2)

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n = int(input())

if n%2 == 0:
  print(n)
else:
  print(n*2)

Solution (Python):
from fractions import gcd

N = int(input())
print(2*N//gcd(2,N))

Solution (Python):
n=int(input())
if n%2:
  print(n*2)
else:
  print(n)

Solution (Python):
n = int( input() )

if( n % 2 == 0 ):
  print(n)
else:
  print(n * 2)

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
if N % 2 == 0 :
    print(N)
else :
    print(2 * N)

Solution (Python):
def main():
    n = int(input())
    if n%2 == 0:
        print(n)
    else:
        print(2*n)


if __name__ == '__main__':
    main()

Solution (Python):
import fractions

def main():
    n = int(input())
    if n%2 == 0:
        print(n)
    else:
        print(2*n)


if __name__ == '__main__':
    main()

Solution (Python):
import fractions

def main():
    n = int(input())
    print(int(2*n/fractions.gcd(2, n)))


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())

if (n % 2 == 0):
   print(n)
else:
   print(n * 2)

Solution (Python):
import math
import fractions
import heapq
import sys
import re
from collections import Counter
import datetime
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN




N=int(input())
print((2*N)//fractions.gcd(2,N))

Solution (Python):
n=int(input())
if n%2==0:print(n)
else:print(2*n)

Solution (Python):
n = int(input())
def gcd(a, b):
	while b:
		a, b = b, a % b
	return a
def lcm(a, b):
	return a * b // gcd (a, b)
print(lcm(2, n))

Solution (Python):
n = int(input())

if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
n=int(input())
print(n if n%2==0 else n*2)

Solution (Python):
n=int(input())
if n%2==0:
  print(n)
else:
  print(n*2)

Solution (Python):
N = int(input())
print(N if N % 2 == 0 else N*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
N=int(input())

if N % 2 == 0:
    print(int(N*2/2))
else:
    print(int(N*2))

Solution (Python):
n = int(input())

if n % 2 == 0:
    print(n)
else:
    print(2*n)

Solution (Python):
n = int(input())
if n % 2 == 0:
    ans = n
else:
    ans = 2*n
print(ans)

Solution (Python):
n = int(input())
if n % 2 != 0:
    print(n*2)
else:
    print(n)

Solution (Python):
n = int(input())

if n%2:
    print(n*2)
else:
    print(n)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
N=int(input())
print(N if N%2==0 else N*2)

Solution (Python):
import sys

n = int(sys.stdin.readline().rstrip())

def main():
    return n * 2 if n & 1 else n

if __name__ == '__main__':
    ans = main()
    print(ans)

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(N*2)

Solution (Python):
N = int(input())

import fractions
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(lcm(2, N))

Solution (Python):
n = int(input())
for i in range(1,100):
    if i*n%2==0:
        print(i*n)
        break

Solution (Python):
i=int(input())
print(i if i%2==0 else i*2)

Solution (Python):
n = int(input())

if n%2 == 0:
    ans = n
else:
    ans = 2*n

print(ans)

Solution (Python):
n = int(input())
if n%2==0:
  print(n)
else:
  print(2*n)

Solution (Python):
n = int(input())

if n % 2 == 0:
  print(n)
else:
  print(2 * n)

Solution (Python):
import sys
import fractions
input = sys.stdin.readline
N = int(input())
print(int(2 * N/(fractions.gcd(2, N))))

Solution (Python):
N = int(input())
if N%2 == 0:
  print(N)
else:
  print(N*2)

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    n=INT()
    if n%2==0:
        print(n)
    else:
        print(2*n)
if __name__ == '__main__':
    do()

Solution (Python):
n=int(input())
if n%2==0:
    print(n)
else:
    print(n*2)

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(N*2)

Solution (Python):
a = int(input())
ans = 0
if a % 2 == 0:
    ans = a
else:
    ans = a * 2
 
print(ans)

Solution (Python):
a = int(input())
ans = 0
if a % 2 == 0:
    ans = a
else:
    ans = a * 2

print(ans)

Solution (Python):
N = int(input())

if N % 2 == 0 :
    ans = N
    
else:
    ans = N * 2
    
print(ans)

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(N * 2)

Solution (Python):
from fractions import gcd

def lcm(a, b):
    return a*b // gcd(a, b)

import sys
input = sys.stdin.readline
N = int(input())
print(lcm(2, N))

Solution (Python):
N = int(input())
if N % 2 == 0:
    print(N)
else:
    print(2*N)

Solution (Python):
a=int(input())
if a%2==0:
  print(a)
else:
  print(a*2)

Solution (Python):
n = int(input())
print(n*2 if n%2 != 0 else n)

Solution (Python):
n=int(input())
if n%2 == 0:
    print(n)
else:
    print(n*2)

Solution (Python):
N = int(input())
print(N if N % 2 == 0 else N*2)

Solution (Python):
n = int(input())
if n % 2 == 0:
    print(n)
else:
    print(n * 2)

Solution (Python):
N = int(input())

if N % 2 == 0:
    print(N)
else:
    print(N * 2)