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):
a = int(input())
if a % 2 == 0:
  print(a)
else:
  print(a*2)

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

print(n if n % 2 == 0 else 2 * 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(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):
import math
N = int(input())
print((2*N)//math.gcd(2,N))

Solution (Python):
import sys
import math


sys.setrecursionlimit(10 ** 8)
ini = lambda: int(sys.stdin.readline())
inm = lambda: map(int, sys.stdin.readline().split())
inl = lambda: list(inm())
ins = lambda: sys.stdin.readline().rstrip()
debug = lambda *a, **kw: print("\033[33m", *a, "\033[0m", **dict(file=sys.stderr, **kw))

N = ini()

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())

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

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


main()

Solution (Python):


def get_input() -> int:
    """
    標準入力を取得する.

    Returns:\n
        int: 標準入力
    """
    N = int(input())

    return N


def main(N: int) -> None:
    """
    メイン処理.

    Args:\n
        N (int): 正整数(1 <= N <= 10^9)
    """
    
    ans = N
    if ans % 2 != 0:
        ans *= 2

    
    print(ans)


if __name__ == "__main__":
    
    N = get_input()

    
    main(N)

Solution (Python):
import math

n = int(input())
gcd = math.gcd(2, n)
lcm = int(2*n/gcd)
ans = lcm

print(ans)

Solution (Python):


N = int(input())


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


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())
if n % 2 == 0:
  print(n)
else:
  print(2*n)

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

if n % 2 == 0:
    print(n)
elif n % 2 != 0:
    print(2 * n)

Solution (Python):
import math
N = int(input())
def lcm(a,b):
    return int(a*b//math.gcd(a,b))
print(lcm(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 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):
a=int(input())
print(a*((a%2)+1))

Solution (Python):
from numpy import lcm
n = int(input())
print(lcm(2, n))

Solution (Python):
import math

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

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

Solution (Python):
import math
N = int(input())
ans = 2 * N // math.gcd(2, N)
print(ans)

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

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

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(N*2)

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

if num % 2 == 0:
    print(num)
else:
    print(num * 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):
import math
n = int(input())
a = math.gcd(n, 2)  
print(n * 2 // a)

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(N*2)

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

    if n % 2 == 0:
        print(n)
    else:
        print(2 * 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())

for i in range(2, 10**6):
    if N % 2 == 0:
        break
    N *= i

print(N)

Solution (Python):

import sys
import math
import numpy as np
import itertools


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())
print(n if n%2==0 else 2*n)

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

Solution (Python):
import math
def lcm(x, y):
    return (x * y) // math.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):
a=int(input())
if a%2==0:
  print(a)
else:
  print(a*2)

Solution (Python):
n=input()
if int(n)%2==0:
  print(n)
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:
  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())
print(2*n if n%2 else n)

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

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(2*n)

Solution (Python):
N = int(input().rstrip())
if N&1==1:
    print(N*2)
else:
    print(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(a*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):
n = int(input())
if n%2==0:
    print(n)
else:
    print(2*n)

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

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

Solution (Python):
import math

n = int(input())

print(2 * n // math.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(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:
    ans=N
else:
    ans=N*2
print(ans)

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

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

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(int(2*(n/2)))

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

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

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

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())

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

    return


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 == 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(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):

def main():
    n = int(input())
    if n % 2 == 0:
        print(n)
    else:
        print(2 * 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())

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):
import math
n = int(input())
print(2 // math.gcd(2, n) * 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());print([2*n,n][n%2==0])

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 math

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

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

Solution (Python):
from math import gcd
def solve():
  N = int(input())
  ans = N*2//gcd(2,N)
  return ans
print(solve())

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

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

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

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

Solution (Python):




import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

n=I()
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):
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):
N = int(input())

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

Solution (Python):
N=int(input())
if N%2==1:
  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 2*n)

Solution (Python):
n=int(input())
if n%2 !=0:
    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(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):
N=int(input())
if 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())
print(n*(n%2+1))

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

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

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

N = I()
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):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    N = I()

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

if __name__ == '__main__':
    resolve()

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

x = k()
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())

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 calculation(lines):
    N = int(lines[0])
    if N % 2 == 0:
        result = N
    else:
        result = N*2
    return [result]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['3']
        lines_export = [6]
    if pattern == 2:
        lines_input = ['10']
        lines_export = [10]
    if pattern == 3:
        lines_input = ['999999999']
        lines_export = [1999999998]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    if len(args) == 1:
        mode = 0
    else:
        mode = int(args[1])
    return mode



def main():
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

Solution (Python):
import math
N = int(input())
print(2*N//math.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(2*n)

Solution (Python):
import math
n = int(input())
print(int(2 * n / math.gcd(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 2*n)

Solution (Python):
import math

if __name__ == '__main__':

	m = 2
	n = int(input())

	ans = n * m // math.gcd(m,n)
	print(ans)

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

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

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

Solution (Python):
import math


n = int(input())

print("{}".format(int(2*n / math.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)
if n % 2 != 0:
    print(n*2)

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

Solution (Python):
N=int(input())
print(N+N%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(raw_input())
print n << (1 if n & 1 else 0)

Solution (Python):
n = int(raw_input())
print (n<< 1) if n & 1 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).is_integer(): 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:
    print(n*2)
else:
    print(n)

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

Solution (Python):
a = int(input())
if int(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(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(N*2)

Solution (Python):
import math
def main():
    n=int(input())
    x=2*n//math.gcd(2,n)
    print(x)
    
if __name__ == "__main__":
    main()

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())
print(n if n % 2 == 0 else n + n)

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

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

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

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

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

Solution (Python):
import sys, os, math, bisect, itertools, collections, heapq, queue

from decimal import Decimal
from collections import defaultdict, deque

sys.setrecursionlimit(10000000)

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: (x * y) // math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


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

    N = ii()
    print([N, N*2][N%2])


if __name__ == '__main__':
    main()

Solution (Python):
import sys, re
from math import ceil, floor, sqrt, pi, factorial, gcd
from copy import deepcopy
from collections import Counter, deque
from heapq import heapify, heappop, heappush
from itertools import accumulate, product, combinations, combinations_with_replacement
from bisect import bisect, bisect_left, bisect_right
from functools import reduce
from decimal import Decimal, getcontext

def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]
def lcm(a, b): return a * b // gcd(a, b)
sys.setrecursionlimit(10 ** 6)
INF = float('inf')
MOD = 10 ** 9 + 7
num_list = []
str_list = []

def main():
    n = i_input()

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

if __name__ == '__main__':
    main()

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

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

Solution (Python):
import math

N = int(input())

print(N*2//math.gcd(2,N))

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

if N%2==0:
    print(N)
if N%2==1:
    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(n * 2)

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

a = 1
b = 0
c = 0

while True:
    c = n * a
    if c % 2 == 0:
        break
    a += 1 
    
print(c)

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

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

Solution (Python):
def solve():
    n = int(input())
    i = n
    while True:
        if i % 2 == 0:
            print(i)
            exit()
        i += n



if __name__ == "__main__":
    solve()

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):
n=int(input())
print(n if n%2==0 else 2*n)

Solution (Python):
import sys
N = int(input())
if not (1 <= N <= 10 ** 9):
    sys.exit()

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

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

n = ri()
print(n if n&1 == 0 else n*2)

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

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

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

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

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

Solution (Python):


N = int(input())

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

print((2 * N) // 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 == 1:
  print(2)
else:
  if n % 2 == 0:
    print(n)
  else:
    print(2 * n)

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

import math

print(int(2*N/math.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())

import fractions

f=fractions.gcd(2,N)
f2=2*N//f
print(f2)

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

Solution (Python):

n = int(input())
print(n<<1) if (n & 1) else print(n)

Solution (Python):

s = int(input())
import math
print((2*s)//math.gcd(2, s))

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 n*2)

Solution (Python):
n=int(input())
if n%2==1:
  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(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([2*n, n][n%2==0])

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

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

elif n%2!=0:
    print(n*2)

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

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

Solution (Python):
import math

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

print(lcm_base(2,int(input())))

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

n1 = N % 2

if n1 == 0:
    n_value = N

else:
    n_value = 2 * N

print(n_value)

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())
print(n if n % 2 == 0 else n * 2)

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10**9)
mod = 10**9+7

N = i()
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())

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 == 0:
	print(n)
else:
	print(n*2)

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

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

Solution (Python):
import sys
from math import gcd

input = sys.stdin.readline


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


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

    ans = lcm(2, N)

    print(ans)


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());print(n*(n%2+1))

Solution (Python):
def main():
    from builtins import int, map, list, print
    import sys
    sys.setrecursionlimit(10 ** 6)

    input = (lambda: (sys.stdin.readline()).rstrip())
    input_list = (lambda: input().split())
    input_number = (lambda: int(input()))
    input_number_list = (lambda: list(map(int, input_list())))

    N = input_number()
    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):
import sys
def input(): return sys.stdin.readline().strip()


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

if __name__ == "__main__":
    main()

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())
ans = 2*n

if n%2 != 0:
    print(ans)
else:
    print(min(ans,n))

Solution (Python):
import fractions

N = int(input())

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

Solution (Python):
import numpy as np

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

N = int(input())
print(int(N * 2 / fractions.gcd(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)
if n%2==1:
  print(n*2)

Solution (Python):
import fractions

N = int(input())

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

Solution (Python):
print((lambda x:x+x*(x%2))(int(input())))

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):
a = int(input())

num = a

if num % 2 != 0:
  num = num * 2

print(num)

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
n = int(input())
print(int((2*n)/fractions.gcd(2, n)))

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

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

print(ans)

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==1:
    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())




import fractions

lcm=(2//fractions.gcd(2,n))*n 

print(lcm)

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())

r = n % 2

if r == 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 os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt
from copy import deepcopy
from fractions import gcd

def main():
    num = int(input())
    ans = 2 * num / gcd(2,num)
    print(int(ans))

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==1:
  print(2)
elif N%2==0 and N>1:
  print(N)
else:
  print(2*N)

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

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

Solution (Python):
def actual(n):
    if n % 2 == 0:
        return n

    return 2 * n

n = int(input())
print(actual(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)