Harryxun/stf_run huggingface dataset:
import numpy as np
A =int(raw_input())
B =int(raw_input())
T =int(raw_input())
print int(np.trunc((T+0.5)/A)*B)

### FIXED CODE ###

import numpy as np
nums = map(int ,raw_input().split())
print str(int(np.trunc((nums[2]+0.5)/nums[0])*nums[1]))
n, k = map(int,input().split())
from math import factorial
ans = []
if n == k:
    ans.append(1)
else:
    for i in range(1, k+1):
        if i >= n-k+1:
            c = 1
        else:
            c = factorial(n-k+1) // (factorial(n-k+1 - i) * factorial(i))
        if i > k-i:
            c2 = int(factorial(i) / (factorial(i-(k-i)) * factorial(k-i)))
        else:
            c2 = 1
        if c > 0:
            ans.append(c*c2)

mod = 10**9 + 7
for j in ans:
    print(j%mod)

### FIXED CODE ###

import math
def C(n,r):
  if n<0 or r<0 or n-r<0:
    return 0
  else:
    return math.factorial(n)//(math.factorial(r)*math.factorial(n-r))
 
n,k=map(int,input().split())
for i in range(1,k+1):
  print(C(n-k+1,i)*C(k-1,i-1)%(10**9+7))
import fractions
a = list(map(int,input().split()))
N = a[0]
b = []
x = list(map(int,input().split()))
x.append(a[1])
x.sort()
flag = 0
for i in range(N):
    c = x[i+1] - x[i]
    if flag == 1:
        ans = fractions.gcd(c, b[i-1]) # 最大公約数を求める
    b.append(c)
    flag = 1
print(ans)

### FIXED CODE ###

import fractions
a = list(map(int,input().split()))
N = a[0]
b = []
x = list(map(int,input().split()))
x.append(a[1])
x.sort()
flag = 0
for i in range(N):
    c = x[i+1] - x[i]
    if flag == 1:
        ans = fractions.gcd(c, ans) # 最大公約数を求める
    else:
        ans = c # 数列が一つの場合は差が答え
    b.append(c)
    flag = 1
print(ans)
import bisect
N = int(input())
S = tuple(map(lambda x: (x**2+x)//2, range(5000)))
while N > 0:
    i = bisect.bisect_left(S, N)
    N -= i
    #print(i, N, S)
    print(i)


### FIXED CODE ###

from string import ascii_uppercase
H, W = [int(i) for i in input().split()]
S = [input().split() for _ in range(H)]
for h in range(H):
    for w in range(W):
        if S[h][w] == "snuke":
            print("{}{}".format(ascii_uppercase[w], h+1))
while True:
	a,b,c=map(str, input().split())
	if b=='?':
		break
	a=int(a)
	c=int(c)
	if b=='+':
		print(a+c)
	elif b=='*':
		print(a*c)
	elif b=='/':
		print(int(a/c))
	else: 
		print(a-c)

### FIXED CODE ###

while True:
	a,b,c=map(str, input().split())
	if b=='?':
		break
	a=int(a)
	c=int(c)
	if b=='+':
		print(a+c)
	elif b=='*':
		print(a*c)
	elif b=='/':
		print(int(a/c))
	elif b=='-':
		print(a-c)
N,K=map(int,input().split())
H=list(map(int,input().split()))
H.sort(reverse=True)
H.remove(H[0:K])
print(sum(H[K:]))

### FIXED CODE ###

N,K=map(int,input().split())
H=list(map(int,input().split()))
H.sort(reverse=True)
print(sum(H[K:]))
MOD = 10**9+7
n = int(input())
m = n - 1
x = list(map(int, input().split()))
d = [x[i+1] - x[i] for i in range(m)]

s = 1
for i in range(2, n):
    s *= i
ans = sum(d) * s % MOD

for i in range(m):
    p = 1
    for j in range(i+1, n-1):
        c = j - i
        p *= c / (c+1)
        ans += d[j] * int(p * s)
        ans %= MOD

print(int(ans))


### FIXED CODE ###

MOD = 10**9+7
n = int(input())
m = n - 1
x = list(map(int, input().split()))
d = [x[i+1] - x[i] for i in range(m)]

inv = [0, 1]
for i in range(2, n):
  inv += [inv[MOD % i] * (MOD - int(MOD / i)) % MOD]

s = 1
for i in range(2, n):
    s *= i
    s %= MOD

ans = s * sum(d) % MOD

p = 0
for i in range(1, m):
    p += inv[i+1]
    p %= MOD
    ans += s * d[i] * p
    ans %= MOD

print(ans)
import numpy as np
a=np.array([[0]*10]*12)
n=int(input())
for i in range(n):
    b,f,r,v=map(int,input().split())
    a[ 3*b-4+f, r-1 ] += v
for i in range(12):
    if i > 0 and i%3==0:
        print('#'*20)
    print(' ', end='')
    print(*a[i,])

### FIXED CODE ###

towers = [
    [[0 for i in range(10)] for j in range(3)] for k in range(4)
]
floor = 3
 
n = int(input())
for i in range(n):
    b,f,r,v = list(map(int,input().split()))
    towers[b-1][f-1][r-1] += v
 
for b in towers:
    for f in b:
        for r in f:
            print(' ' + str(r), end='')
        print('')
    if floor:
        print('#'*20)
        floor -= 1
import math

A,B,H,M = map(int,input().split())

x = 360//12
y = 360//60

a = M*y
b = (H+ M/60)*x

if a>=b:
  if a-b>180:
    k = 360 - a+b
  elif a - b == 180:
    print(A+B)
  else:
    k = a-b
else:
  if b-a>1800:
    k = 360 - b+a
  elif b-a == 180:
    print(A+B)
  else:
    k = b-a
    
k = math.radians(k)

ans = A*A + B*B - 2*A*B*math.cos(k)

print(math.sqrt(ans))

### FIXED CODE ###

import math

A,B,H,M = map(int,input().split())

x = 360//12
y = 360//60

a = M*y
b = (H+M/60)*x
T = 1
if a>=b:
  if a-b>180:
    k = 360 - a+b
  elif a - b == 180:
    print(A+B)
    T = 0
  else:
    k = a-b
else:
  if b-a>180:
    k = 360 - b+a
  elif b-a == 180:
    print(A+B)
    T = 0
  else:
    k = b-a

if T == 1:
  k = math.radians(k)

  ans = A*A + B*B - 2*A*B*math.cos(k)

  print(math.sqrt(ans))
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): 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 LS(): return input().split()

def resolve():
    X, N = LI()
    if N == 0:
        print(X)
        return

    p = LI()

    # p_max = max(p)
    # p_min = min(p)

    # if X < p_min or p_max < X:
    #     print(X)
    #     return
    # else:
    d = [abs(i-X) for i in range(1, 101) if i not in p]
    d_min = min(d)
    for i in range(1, 101):
        if i not in p:
            if abs(i-X)==d_min:
                print(i)
                return

if __name__ == '__main__':
    resolve()


### FIXED CODE ###

import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): 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 LS(): return input().split()

def resolve():
    X, N = LI()
    if N == 0:
        print(X)
        return

    p = LI()

    p_max = max(p)
    p_min = min(p)

    if X < p_min or p_max < X:
        print(X)
        return
    else:
        d = [abs(i-X) for i in range(0, 102) if i not in p]
        d_min = min(d)
        for i in range(0, 102):
            if i not in p:
                if abs(i-X)==d_min:
                    print(i)
                    return

if __name__ == '__main__':
    resolve()
i,j=['ABCDEF',find(X) for x in input().split(' ')]
print('<') if i<j else print('>') if i>j else print('=')

### FIXED CODE ###

i,j=['ABCDEF'.find(x) for x in input().split(' ')]
print('<') if i<j else print('>') if i>j else print('=')
import bisect
N, Q = map(int, input().split())
A = [int(a) for a in input().split()]

def chk(x, l, m, r):
    if x >= A[-2]:
        return 1
    elif x <= A[0]:
        return (N+1)//2
    rr = m % 2
    xl = x - m//2 - rr
    xr = x + m//2
    
    ll = bisect.bisect_left(A, xl)
    rr = bisect.bisect_left(A, xr+1)-1
    # print(x, l, m, r, ll, rr, N)
    if rr - ll + 1 < N - rr - 2:
        if m == (m+r)//2:
            print(1/0)
        return chk(x, m, (m+r)//2, r)
    elif rr - ll + 1 > N - 1 - rr:
        if l == (l+m)//2:
            print(1/0)
        return chk(x, l, (l+m)//2, m)
    else:
        return max(N - rr - 1, 1)
    
    
Y = [0] * (N+1)
for i in range(1, N+1):
    Y[i] = Y[i-1] + A[-i]

Z = [0] * ((N+3)//2)
for i in range((N+1)//2):
    if ((1+N)%2)+2*i<N:
        Z[i+1] = Z[i] + A[((1+N)%2)+2*i]

# print(Y)
# print(Z)
for q in range(Q):
    x = int(input())
    t = chk(x, 0, A[-1]//2, A[-1])
    # print(t)
    print(Y[t]+Z[(N+1)//2-t])


    



### FIXED CODE ###

import sys
input = sys.stdin.readline
def calc(x):
    l, r = 0, (N+1)//2
    while r - l > 1:
        m = (l+r) // 2
        if A[m] + A[2*m] >= 2 * x:
            l = m
        else:
            r = m
    return l
    
N, Q = map(int, input().split())
A = [int(a) for a in input().split()][::-1]
B = [A[0]] + [0] * (N-1)
for i in range(1, N):
    B[i] = B[i-1] + A[i]
C = [A[0]] + [0] * (N-1)
for i in range(2, N, 2):
    C[i] = C[i-2] + A[i]
C[-1] += C[-2]
for _ in range(Q):
    x = int(input())
    c = calc(x)
    print(B[c] + (C[-1] - C[2*c] if c*2<=N else 0))
A = [input() for i in range(N)]
maxA = max(A)
secA = sorted(A)[-2]
num=A.count(maxA)
#print(N,A,maxA,secA,num)

for i in range(N):
  if num>1:
    print(maxA)
  elif A[i]==maxA:
    print(secA)
  else:
    print(maxA)

### FIXED CODE ###

N = int(input())
A = [int(input()) for i in range(N)]
maxA = max(A)
secA = sorted(A)[-2]
num=A.count(maxA)
#print(N,A,maxA,secA,num)
 
for i in range(N):
  if num>1:print(maxA)
  elif A[i]==maxA:print(secA)
  else:print(maxA)
n,t = map(int,input())
A = list(map(int,input().split()))
m = 10**9+1 
M = -1
ans = 0
for i in range(n):
    x = A[i]
    m = min(x)
    p = x-A
    if p > M:
        ans = 0
        M = p
    elif p == M:
        ans += 1
print(ans)

### FIXED CODE ###

n,t = map(int,input().split())
A = list(map(int,input().split()))
m = 10**9+1 
M = -1
ans = 1
for i in range(n):
    x = A[i]
    m = min(x,m)
    p = x-m
    if p > M:
        ans = 1
        M = p
    elif p == M:
        ans += 1
if M <= 0:
    ans = 0
print(ans)
# -*- coding: utf-8

x = input()
a = input().split()
a = a[::-1]
for i range(len(a)):
   b += a[i]+" "
print(b[-1])



### FIXED CODE ###

# -*- coding: utf-8

x = input()
a = input().split()
a = a[::-1]
b = ""
for i in range(len(a)):
   b += a[i]+" "
print(b[:-1])
N = int(input())

def divisor(N):
    '''
    create divisor_list < sqrt(N) from natural number
    '''
    divisor_list = []
    
    for num in range(1, math.ceil(math.sqrt(N)) + 1):
        if N % num == 0:
            divisor_list.append(num)
    
    return divisor_list
    
def F(A, B):
    return max(len(str(A)), len(str(B)))
  
def minimumF(N):
    factoring_list = divisor(N)
    
    candidate_list = []
    
    for A in factoring_list:
        B = N // A
        candidate_list.append(F(A, B))
        
    return min(candidate_list)
  
print(minimumF(N))

### FIXED CODE ###

import math

N = int(input())
 
def divisor(N):
    '''
    create divisor_list < sqrt(N) from natural number
    '''
    divisor_list = []
    
    for num in range(1, math.ceil(math.sqrt(N)) + 1):
        if N % num == 0:
            divisor_list.append(num)
    
    return divisor_list
    
def F(A, B):
    return max(len(str(A)), len(str(B)))
  
def minimumF(N):
    factoring_list = divisor(N)
    
    candidate_list = []
    
    for A in factoring_list:
        B = N // A
        candidate_list.append(F(A, B))
        
    return min(candidate_list)
  
print(minimumF(N))
s = input()
print(s.replace('2017','2018')

### FIXED CODE ###

s = input()
print(s.replace('2017','2018'))
from math import floor
import sys
sys.setrecursionlimit(500000)
T = int(input())
for i in range(T):
    memo = {}
    def buy(A):
        if A < B:
            return False
        else:
            if A % B > C:
                return False
            else:
                A = floor((C-A%B)/B)*B+A%B+D%B
                if A not in memo:
                    memo[A] = 0
                    return buy(A)
                else:
                    return(True)
    A,B,C,D = map(int,input().split())
    if B > D:
        print("No")
    else:
        if buy(A):
            print("Yes")
        else:
            print("No")

### FIXED CODE ###

from math import floor
def gcd(a,b):
    if b == 0:
        return a
    else:
        return gcd(b,a%b)
T = int(input())
for i in range(T):
    A,B,C,D = map(int,input().split())
    if B > D or B > A:
        print("No")
    else:
        if A%B>C:
            print("No")
        else:
            d = gcd(B,D%B)
            r = (A%B)%d
            if B - d + r > C:
                print("No")
            else:
                print("Yes")
x=int(input())
dp=[]*x
dp[0]=1
for i in range(1,x):
  if i-100>=0 and dp[i-100]==1 or dp[i-101]==1 or dp[i-102]==1 or dp[i-103]==1 or dp[i-104]==1 or dp[i-105]==1:
    dp[i]=1
  else:
    dp[i]=0
print(dp[x-1])

### FIXED CODE ###

x=int(input())
if (x//100)*105>=x:
  print(1)
else:
  print(0)
a,b=map(str,input().split())
tempb=float(b)*100
tempa=int(a)
print(int(tempa*tempb/100))

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
ans=1
if 0 in a:
  print(0)
else:
  for i in range(n):
    ans=ans*a[i]
    if ans>10**18:
      print(-1)
      break
  else:
    print(ans)
#!/usr/bin/env python3
import sys
input = sys.stdin.readline

n = int(input())
x = [int(item) for item in list(input().rstrip())]
x.reverse()

ones = x.count(1)
aug = ones + 1
dim = ones - 1

modaug = 0
moddim = 0
for i, item in enumerate(x):
    if item == 1:
        modaug += pow(2, i, aug)
        modaug %= aug
        moddim += pow(2, i, dim)
        moddim %= dim

cnt = [-1] * (2*10**5 + 1)
cnt[0] = 0; cnt[1] = 1
for i in range(1, 2*10**5 + 1):
    val = i
    num = bin(val).count("1")
    cnt[i] = cnt[val % num] + 1

ans = []
for i, item in enumerate(x):
    if item == 0:
        tmp = modaug + pow(2, i, aug)
        tmp %= aug
    else:
        tmp = moddim - pow(2, i, dim)
        tmp %= dim
    ans.append(cnt[tmp] + 1)

ans.reverse()
for item in ans:
    print(item)

### FIXED CODE ###

#!/usr/bin/env python3
import sys
input = sys.stdin.readline

n = int(input())
x = [int(item) for item in list(input().rstrip())]
x.reverse()

ones = x.count(1)
aug = ones + 1
dim = ones - 1

modaug = 0
moddim = 0
for i, item in enumerate(x):
    if item == 1:
        modaug += pow(2, i, aug)
        modaug %= aug
        if dim != 0:
            moddim += pow(2, i, dim)
            moddim %= dim

cnt = [-1] * (2*10**5 + 10)
cnt[0] = 0; cnt[1] = 1
for i in range(1, 2*10**5 + 10):
    val = i
    num = bin(val).count("1")
    cnt[i] = cnt[val % num] + 1

ans = []
for i, item in enumerate(x):
    if item == 0:
        tmp = modaug + pow(2, i, aug)
        tmp %= aug
    else:
        if dim == 0:
            ans.append(0)
            continue
        else:
            tmp = moddim - pow(2, i, dim)
            tmp %= dim
    ans.append(cnt[tmp] + 1)

ans.reverse()
for item in ans:
    print(item)
n=int(input())
h=list(map(int,input().split()))
ans=0
answer=[]
for i in range(n-1):
  if h[i]>=h[i+1]:
    ans+=1
  if h[i]<h[i+1]:
    answer.append(ans)
    ans=0
  if i == n-1:
    answer.append(ans)
print(max(answer))

### FIXED CODE ###

N = int(input())
H = list(map(int,input().split()))
x = 0
lis = []
for i in range(0,len(H)-1) :
    if H[i] - H[i+1] >=0:
        x += 1
    else:
        lis.append(x)
        x =0
lis.append(x)
print(max(lis))
S = input()
c = True
for i in range (len(S)//2):
  if S[i]=S[len(S)//2-i-1]=S[len(S)//2+1+i]=S[len(S)-i-1]:
    c = True
  else:
    c = False
if (c):
  print('Yes')
else:
  print('No')

### FIXED CODE ###

S = input()
c = True
for i in range (len(S)//2):
  if S[i]==S[len(S)//2-i-1]==S[len(S)//2+1+i]==S[len(S)-i-1]:
    c = True
  else:
    c = False
    break
if (c):
  print('Yes')
else:
  print('No')
import fractions
n = int(input())

al = list(map(int,input().split()))

front_gcd = []

a_init = al[0]
for a in al:
    a_init = fractions.gcd(a, a_init)
    front_gcd.append(a_init)
    
back_gcd = []

b_init = al[-1]
for b in al[::-1]:
    b_init = fractions.gcd(b, b_init)
    back_gcd.append(b_init)
    
back_gcd = back_gcd[::-1]

ans = 1
for i in range(n):
    if i == 0:
        x = back_gcd[1]
    elif i == n-1:
        x = front_gcd[-2]
    else:
        x = fractions.gcd(front_gcd[i-1], back_gcd[i+1])
    if gcd > ans:
        ans = x

print(ans)



### FIXED CODE ###

import fractions
n = int(input())

al = list(map(int,input().split()))

front_gcd = []

a_init = al[0]
for a in al:
    a_init = fractions.gcd(a, a_init)
    front_gcd.append(a_init)
    
back_gcd = []

b_init = al[-1]
for b in al[::-1]:
    b_init = fractions.gcd(b, b_init)
    back_gcd.append(b_init)
    
back_gcd = back_gcd[::-1]

ans = 1
for i in range(n):
    if i == 0:
        x = back_gcd[1]
    elif i == n-1:
        x = front_gcd[-2]
    else:
        x = fractions.gcd(front_gcd[i-1], back_gcd[i+1])
    if x > ans:
        ans = x

print(ans)
a,b=map(int,input().split())
B=list(map(int,input().split()))
A=B.copy()
for i in range(b):
  A[i]= abs(A[i]-a)
A.sort()
for i in range(A[-1]+2):
  if A.count(i)==1:
    if i!=0:
      if a-i in B:
        result=a+i
        break
      else:
        result=a-i
        break
  elif A.count(i)==0:
    result=a-i
    break

    
print(result)

### FIXED CODE ###

a,b=map(int,input().split())
if b!=0:
  B=list(map(int,input().split()))
  A=B.copy()
  for i in range(b):
    A[i]= abs(A[i]-a)
  A.sort()
  for i in range(A[-1]+2):
    if A.count(i)==1:
      if i!=0:
        if a-i in B:
          result=a+i
          break
        else:
          result=a-i
          break
    elif A.count(i)==0:
      result=a-i
      break
else:
  result=a
print(result)
n,m,l = [int(i) for i in input().split()]
a = [int(i) for i in input().split()] for j in range(n)]
b = [int(i) for i in input().split()] for j in range(m)]
c = [[0 for i in range(n)] for j in range(l)]
for i in range(n):
    for j in range(l):
        for k in range(m):
            c[i][j] += a[i][k] * b[k][j]
for i in range(l):
    print(' '.join(map(str,c[i])))

### FIXED CODE ###

n,m,l = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
b = [[int(i) for i in input().split()] for j in range(m)]
c = [[0 for i in range(l)] for j in range(n)]
for i in range(n):
    for j in range(l):
        for k in range(m):
            c[i][j] += a[i][k] * b[k][j]
for i in range(n):
    print(' '.join(map(str,c[i])))
h = int(input())
while 2 ** i <= h:
    i += 1
print(2 ** i - 1)

### FIXED CODE ###

i = 0
h = int(input())
while 2 ** i <= h:
    i += 1
print(2 ** i - 1)
H, W = map(int, input().split(" "))

s = [list(input()) for _ in range(0, H)]

d = {}
def walk(i, j, x):
	x += 1
	if (i, j) not in d or x < d[(i, j)]:
		d[(i, j)] = x
		if i-1 >= 0 and s[i-1][j] == '.':
			walk(i-1, j, x)
		if j-1 >= 0 and s[i][j-1] == '.':
			walk(i, j-1, x)
		if i+1 < H and s[i+1][j] == '.':
			walk(i+1, j, x)
		if j+1 < W and s[i][j+1] == '.':
			walk(i, j+1, x)

walk(0, 0, 0)
if (H-1, W-1) in d:
	print("".join(map(lambda x: "".join(x), s)).count(".") - d[(H-1, W-1)])
else:
	print(-1)


### FIXED CODE ###

INF=10*10
H,W=map(int, input().split())
s=[list(input()) for _ in range(H)]
wall=sum(map(lambda x: x.count("#"), s))
d=[[INF for _ in range(W)] for _ in range(H)]
def bfs(h, w, c):
	if d[h][w] <= c:
		return
	d[h][w] = c
	for dh,dw in [(0, -1), (-1, 0), (0, 1), (1, 0)]:
		if h+dh >= 0 and w+dw >= 0 and h+dh < H and w+dw < W and s[h+dh][w+dw] == ".":
			bfs(h+dh, w+dw, c+1)
bfs(0, 0, 1)
print(-1 if d[H-1][W-1] == INF else H*W - d[H-1][W-1] - wall)
import collections
N = int(input())
a = []
b = []
for i in range(int(N/2)):
    a.append(input())
    b.append(input())

ac = collections.Counter(a)
bc = collections.Counter(b)

a_1 = ac.most_common()[0]
b_1 = ac.most_common()[0]

a1_ans = N/2 - a_1[1]
b1_ans = N/2 - b_1[1]
if len(ac.most_common()) == 1:
    a2_ans = N/2
else:
    a2_ans = N/2 - ac.most_common()[1][1]
if len(bc.most_common()) == 1:
    b2_ans = N/2
else:
    b2_ans = N/2 - bc.most_common()[1][1]

if a_1[0] != b_1[0]:
    print(int(a1_ans + b1_ans))
else:
    print(int(max(a1_ans+b2_ans,b1_ans+a2_ans)))

### FIXED CODE ###

import collections

N = int(input())
a = list(int(i) for i in input().split())

b = a[::2]
c = a[1::2]

b_ =collections.Counter(b)
c_ =collections.Counter(c)

baa = b_.most_common()
caa = c_.most_common()

baa.append([0,0])
caa.append([0,0])

if baa[0][0] != caa[0][0]:
    print(N - baa[0][1] - caa[0][1])
else:
    print(min(N - baa[0][1] - caa[1][1],N - caa[0][1] - baa[1][1]))
import collections

N = int(input())
S = [(sorted(input()))for _ in range(N)]
c = collections.Counter(S)
ans = 0
print(S)

for i in set(S):
    n = c[i]
    ans += n*(n-1)//2
print(ans)

### FIXED CODE ###

import collections

N = int(input())
S = [''.join(sorted(input())) for _ in range(N)]
c = collections.Counter(S)
ans = 0
for i in set(S):
    n = c[i]
    ans += n*(n-1)//2
print(ans)
n = int(input())
a = [int(input()) for i in range(n)]

def minkou(a1,a2):
  mod = a1 % a2
  if mod == 0:
    return a2
  else:
    return(minkou(a2,mod))

a1 = a[0]
for i in a[1:]:
  maxkou = a1*i / minkou(a1,i)
  a1 = maxkou
print(int(maxkou))
    

### FIXED CODE ###

n = int(input())
a = [int(input()) for i in range(n)]
def gcd(a,b):
  while b!=0:
    a,b=b,a%b
  return a

 #最小公倍数
def lcm(a,b):
  return a*b//gcd(a,b)

if len(a) ==0:
  print(a[0])
  exit()
else:
  a1 = a[0]
  for i in a:
    a2 = lcm(a1,i)
    a1 = a2
print(a2)
N, M = map(int, input().split())
S = input()
T = input()
import sys
sys.setrecursionlimit(20000)
def gcd(a, b):
    if a < b:
        return gcd(b, a)
    else:
        return a if b == 0 else gcd(b, a % b)


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


L = lcm(N, M)

r = ["*" for i in range(L)]
f = False

s_step = L // N
t_step = L // M
sL = lcm(s_step, t_step)
s = 0
t = 0

for i in range(0, L, sL):
    if i == 0:
        if S[i] == T[i]:
            continue
        else:
            f = True
            break
    else:
        s = i // s_step
        t = i // t_step
        if s > N - 1:
            break
        if t > M - 1:
            break
        if S[s] == T[t]:
            continue
        else:
            f = True
            break

if f:
    print(-1)
else:
    print(L)
N, M = map(int, input().split())
S = input()
T = input()


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


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


L = lcm(N, M)

f = False

s_step = L // N
t_step = L // M
sL = lcm(s_step, t_step)
s = 0
t = 0

for i in range(0, L, sL):
    if i == 0:
        if S[i] == T[i]:
            continue
        else:
            f = True
            break
    else:
        s = i // s_step
        t = i // t_step
        if s > N - 1:
            break
        if t > M - 1:
            break
        if S[s] == T[t]:
            continue
        else:
            f = True
            break

if f:
    print(-1)
else:
    print(L)


### FIXED CODE ###

N, M = map(int, input().split())
S = input()
T = input()
# def gcd(a, b):
#     if a < b:
#         return gcd(b, a)
#     else:
#         return a if b == 0 else gcd(b, a % b)

import fractions
def lcm(a, b):
    return a * b // fractions.gcd(b, a % b)


L = lcm(N, M)

f = False

s_step = L // N
t_step = L // M
sL = lcm(s_step, t_step)
s = 0
t = 0

for i in range(0, L, sL):
    if i == 0:
        if S[i] == T[i]:
            continue
        else:
            f = True
            break
    else:
        s = i // s_step
        t = i // t_step
        if s > N - 1:
            break
        if t > M - 1:
            break
        if S[s] == T[t]:
            continue
        else:
            f = True
            break

if f:
    print(-1)
else:
    print(L)
n=int(input())
s=input()
k=int(input())
s_=str()
for i in range(n):
  if s[i]!=s[k+1]:
    s_+='*'
  else:
    s_+=s[i]

### FIXED CODE ###

n=int(input())
s=input()
k=int(input())
s_=str()
for i in range(n):
  if s[i]!=s[k-1]:
    s_+='*'
  else:
    s_+=s[i]
print(s_)
N = input()

if N % 2 == 0:
    print(0.5)
else:
    print(N//2+1/N)
    

### FIXED CODE ###

N = int(input())

if N % 2 == 0:	
    print((N/2)/N)
else:
    print(((N+1)/2)/N)
MB_TLE = 0
MB_WA = 0
MB_RE = o
MB_AC = 0
n=int(input())
for i in range (n):
    ch = input ()
    if: (ch =="TLE")
     MB_TLE += 1
    if: (ch =="WA")
     MB_WA += 1
    if: (ch =="RE")
     MB_RE += 1
    if: (ch =="AC")
     MB_AC += 1
print('TLE x ',MB_TLE)
print('WA x ',MB_WA)
print('RE x ',MB_RE)
print('AC x ',MB_AC)


### FIXED CODE ###

MB_AC = 0
MB_WA = 0
MB_TLE = 0
MB_RE = 0
n = int(input())
for i in range (n):
    ch = input ()
    if (ch =="AC") :
     MB_TLE += 1
    if (ch =="WA") :
     MB_WA += 1
    if (ch =="TLE") : 
     MB_RE += 1
    if (ch =="RE") :
     MB_AC += 1
print('AC x ',MB_TLE)
print('WA x ',MB_WA)
print('TLE x ',MB_RE)
print('RE x ',MB_AC)