Harryxun/stf_run huggingface dataset:
N = int(input())
A = list(map(int, input().split()))

cnt = [0]*8
c = 0
for a in A:
    if a <= 399:
        cnt[0] += 1
    elif a >= 400 and a <= 799:
        cnt[1] += 1
    elif a >= 800 and a <= 1199:
        cnt[2] += 1
    elif a >= 1200 and a <= 1599:
        cnt[3] += 1
    elif a >= 1600 and a <= 1999:
        cnt[4] += 1
    elif a >= 2000 and a <= 2399:
        cnt[5] += 1
    elif a >= 2400 and a <= 2799:
        cnt[6] += 1
    elif a >= 2800 and a <= 3199:
        cnt[7] += 1
    else:
        c += 1
        
Min = len([i for i in cnt if i != 0]), 0
if c == 0:
    print(Min, Min)
else:
    Max = min(8, Min+c)
    if Min == 0:
        print(1, Max)
    else:
        print(Min, Max)

### FIXED CODE ###

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

cnt = [0]*8
c = 0
for a in A:
    if a <= 399:
        cnt[0] += 1
    elif a >= 400 and a <= 799:
        cnt[1] += 1
    elif a >= 800 and a <= 1199:
        cnt[2] += 1
    elif a >= 1200 and a <= 1599:
        cnt[3] += 1
    elif a >= 1600 and a <= 1999:
        cnt[4] += 1
    elif a >= 2000 and a <= 2399:
        cnt[5] += 1
    elif a >= 2400 and a <= 2799:
        cnt[6] += 1
    elif a >= 2800 and a <= 3199:
        cnt[7] += 1
    else:
        c += 1
        
Min = len([i for i in cnt if i != 0])
if c == 0:
    print(Min, Min)
else:
    Max = Min+c
    if Min == 0:
        print(1, Max)
    else:
        print(Min, Max)
N=int(input())

if  N%2=1
    print((N//2+1)/N)

else  print(1/2)

### FIXED CODE ###

N=int(input())

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

else:
    print(1/2)
c = [list(map(int,input().split())) for _ in range(3)]

def check(c):
  for a1 in range(c[0][0]):
    b = [c[0][i] - a1 for i in range(3)]
    a = [a1] + [c[i][0] - b[0] for i in range(1,3)]

    for ai in a:
      for bi in b:
        if c[ai][bi] != a[ai]+b[bi]:
          print('No')
          return
  print('Yes')

check(c)

### FIXED CODE ###

c = [list(map(int,input().split())) for _ in range(3)]

def check(c):
  for a1 in range(c[0][0]):
    b = [c[0][i] - a1 for i in range(3)]
    a = [a1] + [c[i][0] - b[0] for i in range(1,3)]

    for ai in range(len(a)):
      for bi in range(len(b)):  
        if c[ai][bi] != a[ai]+b[bi]:
          print('No')
          return
  print('Yes')

check(c)
from sys import stdin
N,M,K=list(map(int,input().split()))
friend_list=[set() for _ in range(N+1)]
block_list=[set() for _ in range(N+1)]
def friend_tansaku(i,j):
    color.add(j)
    for friend in friend_list[j]:
        if friend not in color:
            # if friend not in block_list[i] and friend not in candidate and friend not in friend_list[i]:
            candidate.add(friend)
            count[0]+=1
            friend_tansaku(i,friend)




for _ in range(M):
   a,b= list(map(int, input().split()))
   friend_list[a].add(b)
   friend_list[b].add(a)
for _ in range(K):
    a, b = list(map(int, input().split()))
    block_list[a].add(b)
    block_list[b].add(a)
for i in range(1,N+1):
    count=[0]
    color =set()
    candidate=set()
    friend_tansaku(i,i)
    if i==N:print(count[0])
    else:print(count[0],end=" ")

### FIXED CODE ###

from sys import stdin
import sys
import copy
sys.setrecursionlimit(200000)
N,M,K=list(map(int,input().split()))
counter=[[None,None] for i in range(N+1)]
friend_list=[set() for _ in range(N+1)]
block_list=[set() for _ in range(N+1)]
def friend_tansaku(i,j):
    color.add(j)
    cnt[0]+=1
    for friend in friend_list[j]:
        if friend not in color :
            friend_tansaku(i,friend)





for _ in range(M):
   a,b= list(map(int, input().split()))
   friend_list[a].add(b)
   friend_list[b].add(a)
for _ in range(K):
    a, b = list(map(int, input().split()))
    block_list[a].add(b)
    block_list[b].add(a)
for i in range(1,N+1):
    cnt=[0]
    color =set()
    if counter[i][0] is None:
        friend_tansaku(i,i)
        cnt=cnt[0]
        for aa in color:
            counter[aa]=[color,cnt]
    color,cnt =counter[i][0],counter[i][1]
    for k in block_list[i]:
        if k not in color:
            cnt+=1

    count=cnt-(len(friend_list[i])+len(block_list[i]))-1
    if i==N:print(count)
    else:print(count,end=" ")
S = int()
N = len(S)
n = N // 2
ans = 'tes'
for i in range(n):
    p = S[2*i]
    q = S[2*i+1]
    if p == 'L':
        ans = 'No'
    if q == 'R':
        ans = 'No'
if N % 2 == 1:
    if S[N-1] == 'L':
        ans = 'No'
print(ans)

### FIXED CODE ###

S = input()
N = len(S)
n = N // 2
ans = 'Yes'
for i in range(n):
    p = S[2*i]
    q = S[2*i+1]
    if p == 'L':
        ans = 'No'
    if q == 'R':
        ans = 'No'
if N % 2 == 1:
    if S[N-1] == 'L':
        ans = 'No'
print(ans)
c = input()
s = []
for i in c:
    s.append(i)

list_a = []
list_z = []

while "a" in s:
    list_a.append(s.index("a"))
    s[s.index("a")] = "b"

while "z" in s:
    list_z.append(s.index("z"))
    s[s.index("z")] = "v"

answer = list_z[-1] - list_a[0] + 1
print(answer)

### FIXED CODE ###

S = input()
print(S.rfind("Z") - S.find("A")+1)
a

### FIXED CODE ###

s = input()
t = input()
if t[:len(s)] == s:
  print('Yes')
else:
  print('No')
import math

a,b,c,d = map(int,input().split()) 

cd = (c * d) // math.gcd(c, d)
b_c = b // c
b_d = b // d
b_cd = b // cd
a_c = a // c
a_d = a // d
a_cd = a // cd

ans = b - b_c - b_d + b_cd - a + a_c + a_d - a_cd

if a % c != 0 and a % d!= 0:
    ans += 1

print(ans)


### FIXED CODE ###

import fractions

a,b,c,d = map(int,input().split()) 

cd = (c * d) // fractions.gcd(c, d)
b_c = b // c
b_d = b // d
b_cd = b // cd
a_c = a // c
a_d = a // d
a_cd = a // cd

ans = b - b_c - b_d + b_cd - a + a_c + a_d - a_cd

if a % c != 0 and a % d!= 0:
    ans += 1

print(ans)
K=int(input())
A,B=map(int,input().split())


for i in range(1,1000):
    if K * i > 1000
        break
    if K * i >= A and K * i <=B:
        print('OK')
        exit()

print('NG')

### FIXED CODE ###

K=int(input())
A,B=map(int,input().split())


for i in range(1,1000):
    if K * i > 1000:
        break
    if K * i >= A and K * i <=B:
        print('OK')
        exit()

print('NG')
# -*- coding: utf-8 -*-

R = int(input())

if R < 1200:
    print('ABC')
elif R < 2800:
    print('ARC')
elif:
    print('AGC')


### FIXED CODE ###

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

R = int(input())

if R < 1200:
    print('ABC')
elif R < 2800:
    print('ARC')
else:
    print('AGC')
s = input()
RRLRL

l = len(s)
n = 1
rl = []
for i in range(l-1):
    if s[i] == s[i+1] and i != l-2:
        n += 1
    elif s[i] == s[i+1] and i == l-2:
        n += 1
    else:
        rl.append(n)
        n = 1

rl.append(n)

ans = [0]*l
rl_length = len(rl)//2
position = rl[0]

for i in range(rl_length):
    ans[position-1] += -(-rl[i*2]//2) + rl[i*2+1]//2
    ans[position] += rl[i*2]//2 - (-rl[i*2+1]//2)
    if i != rl_length - 1:
        position += (rl[i*2+1] + rl[i*2+2])

for i in range(l):
    if i == l-1:
        print(ans[l-1])
    else:
        print(ans[i],end=" ")


### FIXED CODE ###

s = input()

l = len(s)
n = 1
rl = []
for i in range(l-1):
    if s[i] == s[i+1] and i != l-2:
        n += 1
    elif s[i] == s[i+1] and i == l-2:
        n += 1
    else:
        rl.append(n)
        n = 1

rl.append(n)

ans = [0]*l
rl_length = len(rl)//2
position = rl[0]

for i in range(rl_length):
    ans[position-1] += -(-rl[i*2]//2) + rl[i*2+1]//2
    ans[position] += rl[i*2]//2 - (-rl[i*2+1]//2)
    if i != rl_length - 1:
        position += (rl[i*2+1] + rl[i*2+2])

for i in range(l):
    if i == l-1:
        print(ans[l-1])
    else:
        print(ans[i],end=" ")
n=int(input())
w=list(map(int,input().split()))
ans=10000;

 
for i in range(n):
    s1 += sum(w[:i+1])
    s2 += sum(w[i+1:])
            
    if abs(s1-s2) < ans:
        ans = abs(s1-s2)
    
print(ans)

### FIXED CODE ###

n=int(input())
w=list(map(int,input().split()))
ans=[]
s1=0
s2=0
 
for i in range(n):
    for j in range(0,i):
        s1 += w[j]
    for k in range(i,n):
        s2 += w[k]
    ans.append(abs(s1 - s2))
    s1=0
    s2=0
    
print(min(ans))
import sys
sys.setrecursionlimit(100000)
nCr = {}
def cmb(n, r):
    if r == 0 or r == n: return 1
    if r == 1: return n
    if (n,r) in nCr: return nCr[(n,r)]
    nCr[(n,r)] = cmb(n-1,r) + cmb(n-1,r-1)
    return nCr[(n,r)]

n = int(input())
s=[]
m={}
sum=0
for i in range(0,n):
    # print((list(input()))
    tmp = "".join(sorted(input()))
    if tmp in m:
        m[tmp]+=1
    else:
        m[tmp] = 1
for k in m:
    if m[k]>1:
        # print(m[k])
        # print("["+k)
        sum+=cmb(m[k],2)
print(sum)



### FIXED CODE ###

import sys
sys.setrecursionlimit(10000000)
nCr = {}
def cmb(n, r):
    if r == 0 or r == n: return 1
    if r == 1: return n
    if (n,r) in nCr: return nCr[(n,r)]
    nCr[(n,r)] = cmb(n-1,r) + cmb(n-1,r-1)
    return nCr[(n,r)]

n = int(input())
s=[]
m={}
sum=0
for i in range(0,n):
    # print((list(input()))
    tmp = "".join(sorted(input()))
    if tmp in m:
        m[tmp]+=1
    else:
        m[tmp] = 1
for k in m:
    if m[k]>1:
        # print(m[k])
        # print("["+k)
        sum+=cmb(m[k],2)
print(sum)
n, q = map(int, input().split(' '))


visit = [0 for _ in range(n)]
point = [0 for _ in range(n)]
dic = [[] for _ in range(n)]

def add_p(num):
    if visit[num] == 1:
        return 0
    visit[num] = 1
    for i in dic[num]:
        if visit[i] == 0:
            point[i] += point[num]
            add_p(i)
    return 0

for _ in range(n-1):
    a, b = map(int, input().split(' '))
    dic[a-1].append(b-1)
    dic[b-1].append(a-1)
for _ in range(q):
    p, x = map(int, input().split(' '))
    point[p-1] += x

add_p(0)

print(*point)


### FIXED CODE ###

def main():
    n, q = map(int, input().split(' '))
    import sys
    from collections import deque
    sys.setrecursionlimit(10**7)

    visit = [True for _ in range(n)]
    point = [0 for _ in range(n)]
    dic = [[] for _ in range(n)]
    for _ in range(n-1):
        a, b = map(int, input().split(' '))
        dic[a-1].append(b-1)
        dic[b-1].append(a-1)
    for _ in range(q):
        p, x = map(int, input().split(' '))
        point[p-1] += x
    next_visit = deque()
    next_visit.append(0)
    visit[0] = False
    counter = 1
    while counter < n:
        t = next_visit.pop()
        for s in dic[t]:
            if visit[s]:
                point[s] += point[t]
                visit[s] = False
                counter += 1
                next_visit.append(s)
    print(*point)
if __name__ == '__main__':
    main()
n=int(input())
a=list(map(int,input().split()))
a.sort()
v=a[-1]
a[-1]=a[-1]%a[-2]
a.sort()
l=a[-1]
while v!=l:
    a.sort()
    v=a[-1]
    a[-1]=a[-1]%a[-2]
    a.sort()
    l=a[-1]
if a[-1]==0:
    print(v)
else:
    print(a[-1])

### FIXED CODE ###

import fractions
from functools import reduce
n=int(input())
l=list(map(int,input().split()))
print(reduce(fractions.gcd,l))
h, a = map(int, input())

print(h//a + int(h%a!=0))

### FIXED CODE ###

h, a = map(int, input().split())

print(h//a + int(h%a!=0))
from itertools import accumulate
import bisect
# -*- coding: utf-8 -*-
# python template for atcoder1
import sys
sys.setrecursionlimit(10**9)
input = sys.stdin.readline

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

A_acc = [0]+list(accumulate(A))
ans = 0
# スタート位置を固定して、にぶたん
for l in range(N):
    tmp_acc = [v-A_acc[l] for v in A_acc]
    right = bisect.bisect_left(tmp_acc, K)
    ans += max(N-right+1, 0)

print(ans)


### FIXED CODE ###

X,A=map(int,input().split())
print("1"*(X>=A)+"0")
n = int(input())
list = []
for a in range(1,n-1):
        sum = 0
        sum1 = 0
        b = n - a
        for j in range(len(str(a))):
                sum += int(str(a)[j])
        for k in range(len(str(b))):
                sum1 += int(str(b)[k])
        list.append(sum + sum1)
print(min(list))


### FIXED CODE ###

n = int(input())
l = []
for a in range(1,n):
        sum = 0
        sum1 = 0
        b = n - a
        for i in range(len(str(a))):
                sum += int(str(a)[i])
        for i in range(len(str(b))):
                sum1 += int(str(b)[i])
        l.append(sum+sum1)
print(min(l))
n = int(input())
for _ in range(n):
    x,u = map(int,input().split())
c = 0    
for i in range(n):
    if u[i] == "JPY":
        c += x[i]
    else:
        c += x[i]*380000.0
print(int(c))

### FIXED CODE ###

count = 0
N =int(input())
for _ in range(N):
    x, u =[_ for _ in input().split()]
    x= float(x)
    if u =='JPY':
        count += x
    else:
        count += x * 380000
print(count)
n = int(input())
for i in range(15):
  for j in range(26):
    if 7*i + 4*j == n
      print("Yes")
      exit
      
print(No)

### FIXED CODE ###

n = int(input())
flag = 0
for i in range(15):
  for j in range(26):
    if 7*i + 4*j == n:
      flag = 1
      exit

if flag == 1:
  print("Yes")
else :
  print("No")
mod = 10**9+7
N = int(input())
ans = (pow(a,N,mod) - 2*pow(b, N, mod) + pow(c, N, mod))%mod
if ans < 0:
    ans += mod
print(ans)


### FIXED CODE ###

mod = 10**9+7
N = int(input())
ans = (pow(10,N,mod) - 2*pow(9, N, mod) + pow(8, N, mod))%mod
if ans < 0:
    ans += mod
print(ans)
hoge = input()

huga = hoge ** 3 

print(huga)

### FIXED CODE ###

input_lines = int(input())
print(input_lines **3)
import math

n = int(input())
a = list(map(int, input().split()))

s = [-1, *a[:-1]]
t = [*a[1:], -1]
for x in range(1, n - 1):
    s[x + 1] = math.gcd(s[x + 1], s[x])
for x in range(n - 2, 0, -1):
    t[x - 1] = math.gcd(t[x - 1], t[x])

ans = -float('inf')
for x, y in zip(s, t):
    if x == -1:
        ans = max(ans, y)
    elif y == -1:
        ans = max(ans, x)
    else:
        ans = max(ans, math.gcd(x, y))
    
print(ans)

### FIXED CODE ###

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


n = int(input())
a = list(map(int, input().split()))

# s = [-1, *a[:-1]]
# t = [*a[1:], -1]
s = [-1] * n
t = [-1] * n
for x in range(0, n - 1):
    s[x + 1] = a[x]
for x in range(1, n):
    t[x - 1] = a[x]

for x in range(1, n - 1):
    s[x + 1] = gcd(s[x + 1], s[x])
for x in range(n - 2, 0, -1):
    t[x - 1] = gcd(t[x - 1], t[x])

ans = -float('inf')
for x, y in zip(s, t):
    if x == -1:
        ans = max(ans, y)
    elif y == -1:
        ans = max(ans, x)
    else:
        ans = max(ans, gcd(x, y))
    
print(ans)
N = int(input())
A = [0] * N
for i in range(N):
	A[i] = int(input())

for j in range(1, N):
	if A[j] in A[: j]:
		A[A[: j].index(A[j])] = -1
		A[j] = -1


print(len([k for k in A if k != -1]))


### FIXED CODE ###

def upper_or_lower(i):
    if A[i] < A[i + 1]:
        return "upper"
    elif A[i] > A[i + 1]:
        return "lower"
    else:
        return upper_or_lower(i + 1)


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

state = "upper"  # state が upper か lower で判定
ans = 1

# i = 0 の処理
if (len(A) > 2) and (A[0] > A[1]):
    state = "lower"

for i in range(2, N):
    if (state == "upper") and (A[i - 1] > A[i]):
        ans += 1
        if i < N - 1:
            state = upper_or_lower(i)
    elif (state == "lower") and (A[i - 1] < A[i]):
        ans += 1
        if i < N - 1:
            state = upper_or_lower(i)
    else:
        continue

print(ans)
x = int(input())
bool ok=False
for i in range 9:
	for j in range 9:
		if(i*j==x):
			ok=True
if(ok):print("Yes")
else: print("No")

### FIXED CODE ###

x = int(input())
ok = False
for i in range(1,10):
	for j in range(1,10):
		if i*j==x :
			ok=True
if ok :print("Yes")
else: print("No")
from collections import defaultdict
from copy import copy

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

ms = [2,5,5,4,5,6,3,7,6]
dic = defaultdict(lambda: 0)
for a in A:
    dic[ms[a-1]] = max(dic[ms[a-1]], a)

sd = sorted(dic.items())

dp = [None] * (N+1)
dp[0] = defaultdict(lambda: 0)

for i in range(sd[0][0], N+1):
    cands = []
    for l,a in sd:
        if i-l < 0: break
        if dp[i-l] is None: continue
        cands.append(copy(dp[i-l]))
        cands[-1][a] += 1
    if not cands: continue
    max_v = 0
    max_i = -1
    for i,cand_dic in enumerate(cands):
        tmp_s = ''
        for a,n in sorted(cand_dic.items(), reverse=True):
            tmp_s += str(a) * n
        tmp_v = int(tmp_s)
        if tmp_v > max_v:
            max_v = tmp_v
            max_i = i
    dp[i] = cands[i]

ans = ''
for a,n in sorted(dp[-1].items(), reverse=True):
    ans += str(a) * n
print(ans)

### FIXED CODE ###

from collections import defaultdict
from copy import copy

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

ms = [2,5,5,4,5,6,3,7,6]
dic = defaultdict(lambda: 0)
for a in A:
    dic[ms[a-1]] = max(dic[ms[a-1]], a)

sd = sorted(dic.items())

dp = [None] * (N+1)
dp[0] = defaultdict(lambda: 0)

for i in range(sd[0][0], N+1):
    cands = []
    least_len = -1
    for l,a in sd:
        if i-l < 0: break
        if dp[i-l] is None: continue
        if cands and sum(dp[i-l].values())+1 < least_len:
            continue
        cands.append(copy(dp[i-l]))
        cands[-1][a] += 1
        least_len = sum(cands[-1].values())
    if not cands: continue
    max_v = 0
    max_j = -1
    for j,cand_dic in enumerate(cands):
        tmp_s = ''
        for a,n in sorted(cand_dic.items(), reverse=True):
            tmp_s += str(a) * n
        tmp_v = int(tmp_s)
        if tmp_v > max_v:
            max_v = tmp_v
            max_j = j
    dp[i] = cands[max_j]

ans = ''
for a,n in sorted(dp[-1].items(), reverse=True):
    ans += str(a) * n
print(ans)
import fractions
from functools import reduce

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

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

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

lcm_A = lcm_list(A)

B = [None]*N
for i in range(N):
    B[i] = lcm_A/A[i]

print(int(sum(B)%(10**9+7)))

### FIXED CODE ###

import fractions
import functools
import sys

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

def lcm(*numbers):
    return functools.reduce(lcm_base, numbers, 1)
"""
def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)
"""
N = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))

lcm_A = functools.reduce(lcm_base, A, 1)
B = [None]*N
B = [lcm_A//a for a in A]
#B[i] = lcm_A//A[i]

print(sum(B)%(10**9+7))
N=int(input())
for h in range(1,3501):
  for n in range(1,3501):
    w=(N*h*n)/(4*h*n-N*(n+h))
    if w==int(w):
      print(h,n,w)
      exit()

### FIXED CODE ###

N=int(input())
for h in range(1,3501):
  for n in range(1,3501):
    if (4*h*n-N*n-N*h)>0:
      w=(N*h*n)/(4*h*n-N*n-N*h)
      if w==int(w) and w>0:
        print(h,n,int(w))
        exit()
import sys
nums = input()
print(nums)
a = nums[0] 
b = nums[2]
c = nums[4]

if a == b:
    if b == c:
        print("No")
    else:
        print("Yes")
else:
    if b == c:
        print("Yes")
    elif a == c:
        print("Yes")
    else: 
        print("No")
    

### FIXED CODE ###

import sys
nums = input()
a = nums[0] 
b = nums[2]
c = nums[4]

if a == b:
    if b == c:
        print("No")
    else:
        print("Yes")
else:
    if b == c:
        print("Yes")
    elif a == c:
        print("Yes")
    else: 
        print("No")
import sys
A=" ',-.?ABCDEFGHIJKLMNOPQRSTUVWXYZ"
B="101 000000 000011 10010001 010001 000001 100101 10011010 "\
  "0101 0001 110 01001 10011011 010000 0111 10011000 "\
  "0110 00100 10011001 10011110 00101 111 10011111 1000 "\
  "00110 00111 10011100 10011101 000010 10010010 10010011 10010000".split()
C="ABCDEFGHIJKLMNOPQRSTUVWXYZ .,-'?"
d1={}
for i in range(26):d1[A[i]]=B[i]
for s in sys.stdin:
  x=""
  for c in s[:-1]:x+=d1[c]
  x+="0"*(-len(x)%5)
  s=""
  for i in range(0,len(x),5):s+=C[int(x[i:i+5],2)]
  print s

### FIXED CODE ###

import sys
L="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
A=" ',-.?"+L
B="101 000000 000011 10010001 010001 000001 100101 10011010 "\
  "0101 0001 110 01001 10011011 010000 0111 10011000 "\
  "0110 00100 10011001 10011110 00101 111 10011111 1000 "\
  "00110 00111 10011100 10011101 000010 10010010 10010011 10010000".split()
C=L+" .,-'?"
for s in sys.stdin:
  x=""
  for c in s[:-1]:x+=B[A.index(c)]
  x+="0"*(-len(x)%5)
  s=""
  for i in range(0,len(x),5):s+=C[int(x[i:i+5],2)]
  print s
import math
A, B = [int(_) for _ in input().split()]
print(A * B // math.gcd(A, B))


### FIXED CODE ###

import fractions
A, B = [int(_) for _ in input().split()]
print(A * B // fractions.gcd(A, B))
N = int(raw_input())

answer = "first"
for i in xrange(n):
  a = int(raw_input())
  if not a % 2 == 0:
    answer = "second"
    
print answer
        

### FIXED CODE ###

n = int(raw_input())

answer = "second"

for i in xrange(n):
    a = int(raw_input())
    if not a % 2 == 0:
        answer = "first"

print answer
n,k=map(int,input().split())
LI=list(range(1,n+1))
kari=n+1
for i in range(k):
  d=int(input())
  li=list(map(int,input().split()))
  for x in range(1,n):
    if li.count(x)!=0:
      LI.remove(x)
print(len(LI)-1)
      
      
    

### FIXED CODE ###

n,k=map(int,input().split())
LI=list(range(1,n+1))
kari=n+1
for i in range(1,k+1):
  d=int(input())
  li=list(map(int,input().split()))
  for x in range(1,n+1):
    if li.count(x)!=0:
      if LI.count(x)!=0:
        LI.remove(x)
print(len(LI))
A, B = map(int,input().split())

import math
gcd = 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

l = make_divisors(gcd)
if len(l)==1:
    print(1)
    quit()
l.sort()

l2 = l[:]
for i,x in enumerate(l):
    for y in l[i+1:]:
        if math.gcd(x, y) != 1 and y in l2:
            l2.remove(y)
print(len(l2))


### FIXED CODE ###

A, B = map(int,input().split())
import fractions
_gcd = 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

l = make_divisors(_gcd)
if len(l)==1:
    print(1)
    quit()
l.sort()
aa=False
for x in l:
    if x%2==0:
        aa=x
        break
if aa:
    l2 = [x for x in l if x%2]
    l2.append(aa)
else:
    l2 = l[:]
for i,x in enumerate(l2):
    for y in l2[i+1:]:
        if fractions.gcd(x, y) != 1 and y in l2:
            l2.remove(y)
print(len(l2))
from itertools import combinations


N,M,X=map(int,input().split())

mtable = [None]*N
cs = []
for n in range(N):
    aa = list(map(int,input().split()))
    c = aa.pop(0)
    cs.append(c)
    ms = aa
    mtable[n] = ms
    

# print(mtable)
idxes = list(range(N))

prices = []
for i in range(1, N+1):
    for c in combinations(idxes, i):
        sums = [0]*M
        for idx in c:
            for i, m in enumerate(mtable[idx]):
                sums[i] += m
        if all(map(lambda x:x >= X, sums)):
            price = 0
            for idx in c:
                price += cs[idx]

            prices.append(price)
print(min(prices))

### FIXED CODE ###

from itertools import combinations


N,M,X=map(int,input().split())

mtable = [None]*N
cs = []
for n in range(N):
    aa = list(map(int,input().split()))
    c = aa.pop(0)
    cs.append(c)
    ms = aa
    mtable[n] = ms
    

# print(mtable)
idxes = list(range(N))

prices = []
for i in range(1, N+1):
    for c in combinations(idxes, i):
        sums = [0]*M
        for idx in c:
            for i, m in enumerate(mtable[idx]):
                sums[i] += m
        if all(map(lambda x:x >= X, sums)):
            price = 0
            for idx in c:
                price += cs[idx]

            prices.append(price)
if prices == []:
    print(-1)
else:
    print(min(prices))
N = int(input())
H = list(map(int, input().split()))

_count=1
max_height=H[0]

for i in range(1,N):
    if max_height <= H[i]:
        _count +=1
        max_height = H[i]
print(_count)


### FIXED CODE ###

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

if A==B:
    print(A*2)
else:
    print(2*max(A,B)-1)
n,h,w = map(int,input().split())

print((n-h+1)*(n-w+1))


### FIXED CODE ###

n = int(input())
h = int(input())
w = int(input())

print((n-h+1)*(n-w+1))