Harryxun/stf_run huggingface dataset:
a, b, k = map(int, input().split())
if k == 1:
    print(1)
else:
    num = []
    mini = min(a, b)
    for i in range(1, mini):
        if mini % i == 0:
            num.append(i)
    num.sort()
    print(num[k-1])

### FIXED CODE ###

a, b, k = map(int, input().split())
num = []
mini = min(a, b)
for i in range(1, mini+1):
    if a % i == 0 and b % i == 0:
        num.append(i)
num.sort()
num.reverse()
print(num[k-1])
N = int(input())
s =[]
n = N//2
for i in range(1,n):
  if N % i == 0:
    a = N//i + i
    s.append(a)
print(min(s)-2)

### FIXED CODE ###

N = int(input())
s =N+1
n = int(N**0.5) 
i = 1
while i<=n:
  if N % i != 0:
    i += 1
  elif N % i == 0 and N//i +i < s:
    s = N//i + i
    i += 1
  else:
    i += 1
print(s-2)
# coding: utf-8

N, Q = map(int, input().split())
S = input()


num = [0] * (N+1)
for i in range(N):
    if S[i]=='A' and S[i+1]=='C':
        num[i + 1] = num[i] + 1
    else:
        num[i + 1] = num[i]

        

for i in range(Q):
    l, r = map(int, input().split())
    print( num[r-1] - num[l-1] )


### FIXED CODE ###

# coding: utf-8

N, Q = map(int, input().split())
S = input()

num = [0] * (N+1)

for i in range(N):
    #if S[i]=='A' and S[i+1]=='C':
    if S[i:i+2] =='AC':
        num[i + 1] = num[i] + 1
    else:
        num[i + 1] = num[i]

        

for i in range(Q):
    l, r = map(int, input().split())
    print( num[r-1] - num[l-1] )
import sys

inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

a, b, c, d = inintm()

print(b-a+1 - (-(-(b-a)//c) + -(-(b-a)//d))) + 1

### FIXED CODE ###

import sys
import math

inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

a, b, c, d = inintm()

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

print(b - (b//c + b//d) + b//lcm(c,d) - ((a-1) - ((a-1)//c + (a-1)//d) + (a-1)//lcm(c,d)))
from collections import defaultdict


n, m = map(int, input().split())
d = defaultdict(int)
for i in range(n):
    tmp = list(map(int, input().split()))
    for a in tmp[1:]:
        d[a] += 1
cnt = 0
for value in range(d.values()):
    if value == n:
        cnt += 1
print(cnt)


### FIXED CODE ###

from collections import defaultdict


n, m = map(int, input().split())
d = defaultdict(int)
for i in range(n):
    tmp = list(map(int, input().split()))
    for a in tmp[1:]:
        d[a] += 1
cnt = 0
for value in d.values():
    if value == n:
        cnt += 1
print(cnt)
k,x = list(map(int, input().split()))
print("Yes" if 500*k - x >= 0 "No")

### FIXED CODE ###

k,x = list(map(int, input().split()))
print("Yes" if 500*k - x >= 0 else "No")
import statistics
N = int(input())
L = list(map(int,input().split( )))
f1 = [li-j for li,j in zip(L,range(1+N+1))]
b = statistics.median(f1)
if N%2 != 0:
	ans = sum([abs(li-j-b) for li,j in zip(L,range(1+N+1))])
else:
	b1 = f1[int(b/2-0.5)]
	b2 = f1[int(b/2+0.5)]
	ans1 = sum([abs(li-j-b1) for li,j in zip(L,range(1+N+1))])
	ans2 = sum([abs(li-j-b2) for li,j in zip(L,range(1+N+1))])
	ans = min(ans1,ans2)
print(ans)

### FIXED CODE ###

import statistics
N = int(input())
L = list(map(int,input().split( )))
f1 = [li-j for li,j in zip(L,range(1+N+1))]
b = statistics.median(f1)
if N%2 != 0:
	ans = sum([abs(li-j-b) for li,j in zip(L,range(1+N+1))])
else:
	b1 = int(b+0.5)
	b2 = int(b-0.5)
	ans1 = sum([abs(li-j-b1) for li,j in zip(L,range(1+N+1))])
	ans2 = sum([abs(li-j-b2) for li,j in zip(L,range(1+N+1))])
	ans = min(ans1,ans2)
print(ans)
import numpy as np
A1 = list(map(int, input().split()))
A2 = list(map(int, input().split()))
A3 = list(map(int, input().split()))
N = int(input())
bs = [int(input()) for _ in range(N)]

A = np.array([A1, A2, A3])
mask = np.zeros_like(A)
for b in bs:
    mask += (A==b).astype(int)

mask = mask>0
if np.any(np.all(mask, axis=0)):
    print('Yes')
elif np.any(np.all(mask, axis=1)):
    print('Yes')
elif np.all(np.diag(mask)):
    print('Yes')
# elif np.all(np.diag(mask.T)):
elif np.logical_and(mask[0][2], mask[1][1], mask[2][0]):
    print('Yes')
else:
    print('No')


### FIXED CODE ###

import numpy as np
A1 = list(map(int, input().split()))
A2 = list(map(int, input().split()))
A3 = list(map(int, input().split()))
N = int(input())
bs = [int(input()) for _ in range(N)]

A = np.array([A1, A2, A3])
mask = np.zeros_like(A)
for b in bs:
    mask += (A==b).astype(int)

mask = mask>0
if np.any(np.all(mask, axis=0)):
    print('Yes')
elif np.any(np.all(mask, axis=1)):
    print('Yes')
elif np.all(np.diag(mask)):
    print('Yes')
# elif np.all(np.diag(mask.T)):
elif mask[0][2]&mask[1][1]&mask[2][0]:
    print('Yes')
else:
    print('No')
n, a, b = map(int, input().split())
priunt(min(a * n, b))

### FIXED CODE ###

n, a, b = map(int, input().split())
print(min(a * n, b))
n = int(input())
t,a = map(int,input().split())
li = list(map(int,input().split()))
nearest = 0
for i in li:
    if abs(nearest - a) < abs((t - i * 0.006) - a):
        nearest = i
print(li.index(nearest) + 1)

### FIXED CODE ###

N = int(input())
T, A = map(int, input().split())
H = list(map(int, input().split()))
dif = 1000
for i in range(N):
    Tx = T - H[i] * 0.006
    if  abs(Tx - A) < dif:
        dif = abs(Tx - A)
        ans = i + 1
print(ans)
A,B=map(int,input().split())
n=A-(B*2)
if n>=0:
    print(n)
else:
    print(o)

### FIXED CODE ###

A,B=map(int,input().split())
n=A-(B*2)
if n>=0:
    print(n)
else:
    print(0)
from collections import *
import itertools
import sys
try: inp = raw_input
except: inp = input
def err(s):
    sys.stderr.write('{}\n'.format(s))

def ni():
    return int(inp())

def nl():
    return [int(_) for _ in inp().split()]

N = ni()
A = nl()

X = sorted(enumerate(A), key=lambda x: x[1], reverse=True)
p = [x for x, _ in X]
sc = [x for _, x in X]

DP = {}
def opt(l, r, i):
    if i == N: return 0
    T = l, r, i
    if T in DP:
        return DP[T]
    v1 = abs(p[i]- l)*sc[i] + opt(l+1, r, i+1)
    v2 = abs(p[i] - r)*sc[i] + opt(l, r-1, i+1)
    DP[T] = max(v1, v2)
    return DP[T]

print(opt(0, N-1, 0))


### FIXED CODE ###

from collections import *
import itertools
import sys
sys.setrecursionlimit(10**5)
try: inp = raw_input
except: inp = input
def err(s):
    sys.stderr.write('{}\n'.format(s))

def ni():
    return int(inp())

def nl():
    return [int(_) for _ in inp().split()]

N = ni()
A = nl()

X = sorted(enumerate(A), key=lambda x: x[1], reverse=True)
p = [x for x, _ in X]
sc = [x for _, x in X]

DP = [[-1]*N for _ in range(N)]
def opt(l, i):
    r = N - i + l - 1
    if i == N: return 0
    if DP[i][l] != -1: return DP[i][l]
    v1 = abs(p[i]- l)*sc[i] + opt(l+1, i+1)
    v2 = abs(p[i] - r)*sc[i] + opt(l, i+1)
    DP[i][l] = max(v1, v2)
    return DP[i][l]

print(opt(0, 0))
nen,mon,day = map(int,input().split('/'))

if nen >= 2019:
  if mon >= 5:  
    print("Heisei")
  else if day >= 30 and mon ==4:
    print("Heisei")
else:
    print("TBD")


### FIXED CODE ###

S = input()

if S <= "2019/04/30":
    print("Heisei")
else:
    print("TBD")
n=int(input())
for x in range(n):
  a,b=input().split()
  lists.append([a,int(b),x+1])
lists.sort(key=lambda t:t[1],reverse=True)
lists.sort(key=lambda t:t[0])
for x in range(n):
  print(lists[x][2])

### FIXED CODE ###

n=int(input())
lists=[]
for x in range(n):
  a,b=input().split()
  lists.append([a,int(b),x+1])
lists.sort(key=lambda t:t[1],reverse=True)
lists.sort(key=lambda t:t[0])
for x in range(n):
  print(lists[x][2])
penaltyCount = dict()
penaltyCount = defaultdict(lambda: 0, penaltyCount)
 
correct = 0
penalty = 0
 
for i in range(m):
    submission = input.split()
    p = int(submission[0]) - 1
    status = submission[1]


### FIXED CODE ###

import sys
from collections import defaultdict

n, m = map(int, input().split())
ac = 0
wa = defaultdict(lambda: 0)
already = set()
for line in sys.stdin:
    y, z = line.strip().split()
    y = int(y)
    if y in already:
        continue
    if z == 'AC':
        ac += 1
        already.add(y)
    else:
        wa[y] += 1
    
print(ac, sum(wa[i] for i in already))
print(int(input()//2)

### FIXED CODE ###

n=int(input())
if n%2==0:
  print(n//2)
else:
  print(n//2 +1)
def resolve():
    N = int(input())
    all = list(map(int, input().split()))
    ans = 0
    for i in all:
        ans += 1/i
    print(dad)
resolve()

### FIXED CODE ###

def resolve():
    N = int(input())
    all = list(map(int, input().split()))
    ans = 0
    for i in all:
        mom = 1/i
        ans += mom
    dad = 1/ans
    print(dad)
resolve()
import math
import sys
sys.setrecursionlimit(2000000000)
a,b= list(map(int, input().split()))
ma=math.gcd(a,b)
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

def is_prime(n):
    if n == 1: return False

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False

    return True
ans=1
for i in make_divisors(ma):
    if is_prime(i):
        ans+=1
print(ans)

### FIXED CODE ###

import math
import fractions
import sys
sys.setrecursionlimit(2000000000)
a,b= list(map(int, input().split()))
ma=fractions.gcd(a,b)
def make_divisors(n):
    divisors = []
    for i in range(1, int(n**0.5)+1):
        if n % i == 0:
            divisors.append(i)
            if i != n // i:
                divisors.append(n//i)
    return divisors

def is_prime(n):
    if n == 1: return False

    for k in range(2, int(math.sqrt(n)) + 1):
        if n % k == 0:
            return False

    return True
ans=1
for i in make_divisors(ma):
    if is_prime(i):
        ans+=1
print(ans)
# -*- coding: utf-8 -*-

# AtCoder Beginner Contest
# Problem C


def dfs(pos, mask):
    if pos == n:
        if len(set(p)) == n:
            pass_count = 1

            for i in range(n - 1):
                if graph[p[i]][p[i + 1]] == 1:
                    pass_count += 1

            if pass_count == n:
                global count
                count += 1
        return

    # See:
    # https://www.youtube.com/watch?v=UFMvexj1hY4
    for i in range(n):
        if mask and (1 << i):  # i in mask.
            p[pos] = i
            dfs(pos + 1, mask ^ (1 << i))  # remove i from mask.


if __name__ == '__main__':
    n, m = list(map(int, input().split()))
    ab = [list(map(lambda x: int(x) - 1, input().split())) for _ in range(m)]
    graph = [[0 for __ in range(m)] for _ in range(m)]
    p = [0] * n
    count = 0

    for a, b in ab:
        graph[a][b] = 1

        if a != 0:
            graph[b][a] = 1

    dfs(0, (1 << n) - 1)  # permutation [0, n - 1]

    print(count)


### FIXED CODE ###

# -*- coding: utf-8 -*-

# AtCoder Beginner Contest
# Problem C


# See:
# https://atcoder.jp/img/abc054/editorial.pdf
def dfs(v):
    all_visited = True

    if False in visited:
        all_visited = False

    if all_visited:
        return 1

    count = 0

    for i in range(n):
        if graph[v][i] == 0:
            continue

        if visited[i]:
            continue

        visited[i] = True
        count += dfs(i)
        visited[i] = False
    return count


if __name__ == '__main__':
    n, m = list(map(int, input().split()))
    graph = [[0 for __ in range(n)] for _ in range(n)]

    for i in range(m):
        a, b = list(map(lambda x: int(x) - 1, input().split()))
        graph[a][b] = 1
        graph[b][a] = 1

    visited = [False] * n
    visited[0] = True

    print(dfs(0))
n, k = map(int, raw_input().split())
l = map(int, raw_input().split())
totallen = sum(l)
h = []
i = 0
j = n - 2
ans = []
while i <= j:
	if totallen < k:
		break
	else:
		if l[i] < l[j]:
			ans.append(i + 1)
			totallen -= l[i]
			i += 1
		else:
			ans.append(j + 1)
			totallen -= l[j+1]
			j -= 1
if len(ans) == n - 1:
	print "Possible"
	for i in ans:
		print i 
else:
	print "Impossible"

### FIXED CODE ###

l, r = map(int, raw_input().split())
if l <= 0 <= r:
	print "Zero"
elif l > 0:
	print "Positive"
else:
	if (r - l)%2 == 0:
		print "Negative"
	else:
		print "Positive"
R = input()

if (R<1) & (R>100):
  continue
  
else:
  print(2*3.14159*R)

### FIXED CODE ###

ennshuuritsu = 3.1415
nyuuryoku = int(input())

print(nyuuryoku*2*ennshuuritsu)
N=int(input())
A=[int(input()) for _ in range(N)]
 
ans=0
for i in range(N):
  if A[i]==0:
    idx.append(i+1)
  
n=0
for iidx in idx:
  ans+=sum(A[n:iidx])//2
  n=iidx
print(ans)

### FIXED CODE ###

N=int(input())
A=[int(input()) for _ in range(N)]

ans=0
idx=[]
for i in range(N):
  if A[i]==0:
    idx.append(i+1)
n=0
idx.append(N)
for iidx in idx:
  ans+=sum(A[n:iidx])//2
  n=iidx
print(ans)
N,M = map(int,input().split())
A = ['a']*N
for _ in range(M):
  s,c = map(int,input().split())
  if A[s-1] !='a' and A[s-1] != c:
    print(-1)
    exit()
  else:
    A[s-1] = c

for i in range(N):
  if A[0] == 'a' and N==3:
    A[0] = 1
  else A[i] == 'a':
    A[i] = 0
Answer = ''.join(map(str,A))

if Answer != '0' and len(Answer) != N:
  Answer = -1
if Answer == '000':
  Answer = -1
print(Answer)


### FIXED CODE ###

N,M = map(int,input().split())
ret = ['a']*N
for _ in range(M):
  s,c = map(int,input().split())
  if ret[s-1] not in ['a', c]:
    print(-1)
    exit()
  ret[s-1] = c
if ret[0] == 0:
  if N != 1:
    print(-1)
    exit()
ans = ''
for i in range(N):
  if ret[i] != 'a':
    ans += str(ret[i])
  else:
    if i == 0 and N > 1:
      ans += '1'
    else:
      ans += '0'
print(int(ans))
x = 3
print x^3



### FIXED CODE ###

x = int(input())
print (x ** 3)
import numpy as np
N = int(input())
a = [int(_) for _ in input().split()]
a = np.array(a)
a = np.sort(a)
min = 0
max = 0
m = 0

for i in range(8):
    set_1 = set(np.where(i*400<=a)[0])
    set_2 = set(np.where(a<(i+1)*400)[0])
    match = list(set_1 & set_2)
    if len(match)>0:
        min+=1
if min=0:
    min=1
    if N>8:
	max = 8
    else:
	max = N
else:
    if len(np.where(a>=3200)[0])==0:
        max = min
    else:
        max = min + len(np.where(a>=3200)[0])
    	if max>8:
            max = 8
print (min, max)


### FIXED CODE ###

import numpy as np
N = int(input())
a = [int(_) for _ in input().split()]
a = np.array(a)
a = np.sort(a)
min = 0
max = 100

for i in range(8):
    set_1 = set(np.where(i*400<=a)[0])
    set_2 = set(np.where(a<(i+1)*400)[0])
    match = list(set_1 & set_2)
    if len(match)>0:
        min+=1
if min==0:
    min=1
    max = N
else:
    if len(np.where(a>=3200)[0])==0:
        max = min
    else:
        max = min + len(np.where(a>=3200)[0])
print (min, max)
import math
from functools import reduce


dic = {}
ans = 0
n = int(input())
for i in range(n):
    for j in range(n):
        for k in range(n):
            key=(i+1)*(j+1)*(k+1)
            if key in dic:
                ans = ans+dic[key]
            else:
                val = gcd(gcd(i+1, j+1), k+1)
                dic[key] = val
                ans = ans + val
print(ans)

### FIXED CODE ###

from math import gcd
k = int(input())+1
ans = 0
for i in range(1,k):
    for j in range(1,k):
        for l in range(1,k):
            ans+=gcd(gcd(i,j),l)
print(ans)
import math
from functools import reduce

N, K = map(int, input().split())
A = list(map(int, input().split()))


def gcd(numbers):
    return reduce(math.gcd, numbers)

if K > max(A):
    print('IMPOSSIBLE')
elif K % gcd(A) != 0:
    print('IMPOSSIBLE')
else:
    print('POSSIBLE')


### FIXED CODE ###

import fractions
from functools import reduce

N, K = map(int, input().split())
A = list(map(int, input().split()))


def gcd_list(numbers):
    return reduce(fractions.gcd, numbers)


if K > max(A):
    print('IMPOSSIBLE')
elif K % gcd_list(A) != 0:
    print('IMPOSSIBLE')
else:
    print('POSSIBLE')
x=int(input())
k=360%x
j=360//x
v=k
while 360%k!=0:
    k=360%k
    v+=k
v1=360//v
print(j*v1)

### FIXED CODE ###

def do():
    x=int(input())
    k=360%x
    j=360//x
    v=k
    if k==0:
        return j
    while 360%k!=0:
        k=360%k
        v+=k
    v1=360//v
    return j*v1
print(do())
R=int(input().split())
print(2*R*3.14)

### FIXED CODE ###

R=int(input())
print(2*R*3.14)
a, b = map.(int, input().split())
print("Even" if a * b % 2 == 0 else "Odd")

### FIXED CODE ###

a, b = map(int, input().split())
print("Even" if a * b % 2 == 0 else "Odd")
s = list(input())
t = list(input())

ln = len(s)
lt = len(t)
n = ls - lt + 1
l = []

cnt = 0
for i in range(n):
    for j in range(lt):
        if t[j] != s[i + j]:
            cnt += 1
    l.append(cnt)
    cnt = 0
    
print(min(l))
        

### FIXED CODE ###

s = list(input())
t = list(input())

ls = len(s)
lt = len(t)
n = ls - lt + 1
l = []

cnt = 0
for i in range(n):
    for j in range(lt):
        if t[j] != s[i + j]:
            cnt += 1
    l.append(cnt)
    cnt = 0
    
print(min(l))
import math

def is_prime(n):
  if n == 1: return False
  for k in range(2, int(math.sqrt(n)) + 1):
    if n % k == 0:
      return False
  return True

n = int(input())
if is_prime(n):
  print(int(math.log(a,10))+1)
k = int(math.sqrt(n))
for i in range(k,n+1):
  if n%i == 0:
    a = i
    break
s = int(math.log(a,10))+1
print(s)

### FIXED CODE ###

import math
n = int(input())
k = int(math.sqrt(n))
for i in range(k+2,0,-1):
  if n%i == 0:
    a = n//i
    break
s = len(str(a))
print(s)
from bisect import bisect_left as bl
from bisect import bisect_right as br
from itertools import combinations as cmb
from itertools import combinations_with_replacement as cmbwr
from itertools import permutations as prm
from itertools import accumulate as acm
from math import gcd
from math import ceil
from math import factorial as fact
from collections import deque
from collections import Counter
from heapq import heappop as hpp
from heapq import heappush as hps
import sys
sys.setrecursionlimit(10 ** 6)
INF = 10 ** 20
direct = ((1, 0), (0, 1), (-1, 0), (0, -1))
def ilinp(): return list(map(int, input().split()))
def slinp(): return input().split()
def iinp(): return int(input())

a, b = ilinp()
if a + b == 15:
  print("+")
elif a* b == 15:
  print("*")
else:
  print("x")

### FIXED CODE ###

def ilinp(): return list(map(int, input().split()))
def slinp(): return input().split()
def iinp(): return int(input())

a, b = ilinp()
if a + b == 15:
  print("+")
elif a* b == 15:
  print("*")
else:
  print("x")
a,b=input(int,input().split())
if a<10 and b<10:
  print(a*b)
else:
  print("-1")

### FIXED CODE ###

a,b=map(int,input().split())
if a<=9 and b<=9:
  print(a*b)
else:
  print(-1)
n = int(raw_input())

if n == 1:
  print("Hello World")
elif n == 2:
  a = int(raw_input())
  b = int(raw_input())
  print(a+b)

### FIXED CODE ###

n = int(input())
 
if n == 1:
  print("Hello World")
elif n == 2:
  a = int(input())
  b = int(input())
  print(a+b)
a = input()
print(a+a^2+a^3)

### FIXED CODE ###

a = int(input())
n = 2
m = 3
print(a + a ** n + a ** m)
n,k=map(int,input().split())
s=input()
for i in n:
	if i==k:
        if i=='A':
            i='a'
        elif i=='B':
            i='b'
        elif i=='C':
            i='c'        
print(i)
    

### FIXED CODE ###

n,k=map(int,input().split())
S=list(input())
s=S[k-1].lower()
S[k-1]=s
lst=''.join(S)
print(lst)
n1 = int(input())
n2 = int(input())
 
#print(n1)
#print(n2)
 
if n1 == 1:
  if n2 == 2:
    print("3")
  else:
    print("2")
else n1 == 2:
  if n2 == 1:
    print("3")
  else:
    print("1")
else n1 ==3:
  if n2 == 1:
    print("2")
  else:
    print("1")

### FIXED CODE ###

n1 = int(input())
n2 = int(input())
 
#print(n1)
#print(n2)
 
if n1 == 1:
  if n2 == 2:
    print("3")
  else:
    print("2")
elif n1 == 2:
  if n2 == 1:
    print("3")
  else:
    print("1")
elif n1 ==3:
  if n2 == 1:
    print("2")
  else:
    print("1")
A,X =map(int,input().split())
if X < A :
  print(0)
elif:
  print(10)

### FIXED CODE ###

X,A =map(int,input().split())
if X < A:
  print(0)
else:
  print(10)
int(input())
list=[s]
num=2
while num<=1000000:
  if num%2==0:
    list.append(list[num-2]/2)
  else:
    list.append(list[num-2]*3+1)
  if list[num-1] in list[:num-1]:
    break
  num+=1
print(num)

### FIXED CODE ###

s=int(input())
list=[s]
num=2
while num<=1000000:
  if list[num-2]%2==0:
    list.append(list[num-2]/2)
  else:
    list.append(list[num-2]*3+1)
  if list[num-1] in list[:num-1]:
    break
  num+=1
print(num)
A,B,C,D,E,F = map(int,input().split())
smax =int(F*E/(100+E))
wmax =F-smax
temp = []
for a in range(wmax//(A*100)+1):
    for b in range(wmax // (B*100)+1):
        for c in range(smax // (C)+1):
            for d in range(smax // (D)+1):
                if a == 0 and b== 0:
                    pass
                elif (c*C+d*D)/(100*a*A+100*b*B+c*C+d*D)<=E/(100+E) and 100*a*A+100*b*B <=wmax and c*C+d*D <=smax:
                    temp.append([100*a*A+100*b*B+c*C+d*D,c*C+d*D,(c*C+d*D)/(100*a*A+100*b*B+c*C+d*D)])
a = sorted(temp,key= lambda x:x[2],reverse=True)
print(str(a[0][0])+' '+str(a[0][1]))

### FIXED CODE ###

from math import ceil
A,B,C,D,E,F = map(int,input().split())
am,bm,cm,dm=ceil(31/A),ceil(31/B),ceil(F*E/(100+E)/C)+1,ceil(F*E/(100+E)/D)+1
temp = []
for a in range(am):
    for b in range(bm):
        for c in range(cm):
            for d in range(dm):
                w = 100*a*A+100*b*B
                s = c*C+d*D
                if w + s > F:
                    break
                else:
                    if w / 100 * E >= s:
                        temp.append([w+s,s])
print(*sorted(temp, key=lambda x: (100*x[1] / x[0] if x[0] else 0))[-1])
a,b=map(int,input().split())
s=sorted([input() for i in range(n)])
print(*s,sep="")


### FIXED CODE ###

n,l=map(int,input().split())
s=sorted([input() for i in range(n)])
print(*s,sep="")
from operator import mul
from functools import reduce


def cmb(n, r):
    r = min(n - r, r)
    if r == 0:
        return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1, r + 1))
    return over // under


N, K = map(int, input().split())

for i in range(1, K + 1):
    if N == K:
        print(0)
    else:
        print((cmb(N - K + 1, i) * cmb(K - 1, i - 1)) % (10**9 + 7))


### FIXED CODE ###

from operator import mul
from functools import reduce


def cmb(n, r):
    r = min(n - r, r)
    if r == 0:
        return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1, r + 1))
    return over // under


N, K = map(int, input().split())

for i in range(1, K + 1):
    if N - K + 1 < i:
        print(0)
    else:
        print((cmb(N - K + 1, i) * cmb(K - 1, i - 1)) % (10**9 + 7))
d1 = list(map(int ,input().split())
d2 = list(map(int ,input().split())
if d2[0] != d1[0]:
          print(1)
else:
          print(0)
       
        

### FIXED CODE ###

d1 = list(map(int ,input().split()))
d2 = list(map(int ,input().split()))
if d2[0] != d1[0]:
          print(1)
else:
          print(0)
n = int(input())
S = list(map(int, input().split()))
S = sorted(S)
print(S[-1] - S[0])


### FIXED CODE ###

n = int(input())

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

else:
    print(2 * n)