Harryxun/stf_run huggingface dataset:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10**9 + 7
from decimal import *

a, b, c = MAP()
 
if Decimal(a)**0.5 + Decimal(b)**0.5 < Decimal(c)**0.5:
	print("Yes")
else:
	print("No")


### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians#, log2
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy, copy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np

a, b, c = MAP()
if 4*a*b < (c-a-b)**2 and c-a-b > 0:
	print("Yes")
else:
	print("No")
def B():
    n = int(input())
    a = input().split()
    
    if(len(a) != n):
        exit(1)

    i_max = 0
    i_min = 1000000001
    for i in a:
        k = int(i)
        if (i_max < k):
                i_max = k
        if (i_min > k):
                i_min = k
    print(i_max,i_min)
    print(abs( i_max - i_min))

if __name__ =='__main__':
    B()

### FIXED CODE ###


if __name__ =='__main__':
    a = input()
    try:
        x = int(a)
    except:
        exit(1)

    if(x % 2 != 0):
         x = x*2
    
    print(x)
# coding: utf-8
import math

n = int(input().rstrip())
numbers = [int(i) for i in input().rstrip().split(" ")]

l_list = [numbers[0]]
for i in range(1, n):
    l_list.append(math.gcd(l_list[i - 1], numbers[i]))

r_list = [numbers[len(numbers) - 1]]
for i in reversed(range(0, n - 1)):
    r_list.insert(0, math.gcd(r_list[0], numbers[i]))

ans = 0
for i in range(n):
    l = 0
    if i > 0:
        l = l_list[i - 1]
    r = 0
    if i < n - 1:
        r = r_list[i + 1]
    if l == 0:
        l = r
    if r == 0:
        r = l
    ans = max(ans, math.gcd(l, r))
print(ans)


### FIXED CODE ###

# coding: utf-8
import fractions

n = int(input().rstrip())
numbers = [int(i) for i in input().rstrip().split(" ")]

l_list = [0 for i in range(n)]
l_list[0] = numbers[0]
for i in range(1, n):
    l_list[i] = fractions.gcd(l_list[i-1], numbers[i])

r_list = [0 for i in range(n)]
r_list[n-1] = numbers[n-1]
for i in reversed(range(0, n - 1)):
    r_list[i] = fractions.gcd(r_list[i+1], numbers[i])

ans = 0
for i in range(n):
    l = 0
    if i > 0:
        l = l_list[i - 1]
    r = 0
    if i < n - 1:
        r = r_list[i + 1]
    if l == 0:
        l = r
    if r == 0:
        r = l
    ans = max(ans, fractions.gcd(l, r))
print(ans)
D=int(input())
if D==25:
    print("Christmas")
else if D==24:
    print("Christmas Eve")
else if D==23:
    print("Christmas Eve Eve")
else if D==22:
    print("Christmas Eve Eve Eve")

### FIXED CODE ###

D=int(input())
if D==25:
    print("Christmas")
elif D==24:
    print("Christmas Eve")
elif D==23:
    print("Christmas Eve Eve")
elif D==22:
    print("Christmas Eve Eve Eve")
N = int(input())
a = [[0 for j in range(19)] for i in range(19)]
for i in range(N):
    A=input()
    tmp = int(A.replace('.', ''))
    count2 = 0
    count5 = 0
    for _ in range(18):
        if tmp % 2 == 0:
            count2 += 1
            tmp //= 2
        else:
            break
    for _ in range(18):
        if tmp % 5 == 0:
            count5 += 1
            tmp //= 5
        else:
            break
    if A.find('.') > 0:
        count2 = count2 + 10 - len(A) + A.find('.')
        count5 = count5 + 10 - len(A) + A.find('.')
    else:
        count2 += 9
        count5 += 9
    a[count2][count5] += 1
ans=0
for i in range(19):
    for i2 in range(19):
        for j in range(19):
            for j2 in range(19):
                if i + i2 >= 18 and j + j2 >= 18 and ( i < i2 or i == i2 and j <= j2) and a[i][j] >0 and a[i2][j2] > 0:
                    if i == i2 and j == j2:
                        ans += a[i][j] * (a[i][j]-1) // 2
                    else:
                        ans += a[i][j] * a[i2][j2]
print(ans)


### FIXED CODE ###

N = int(input())
a = [[0 for j in range(19)] for i in range(19)]
ans=0
for _ in range(N):
    A=input()
    if A.find('.') > 0:
        count2 = 10 - len(A) + A.find('.')
        count5 = 10 - len(A) + A.find('.')
    else:
        count2 = 9
        count5 = 9
    tmp = int(A.replace('.', ''))
    while count2 < 18:
        if tmp % 2 == 0:
            count2 += 1
            tmp //= 2
        else:
            break
    while count5 < 18:
        if tmp % 5 == 0:
            count5 += 1
            tmp //= 5
        else:
            break
    for i in range(18-count2,19):
        for j in range(18-count5,19):
            ans += a[i][j]
    a[count2][count5] += 1
print(ans)
s = int(input())
 
if (s[-1]==2,4,5,7,9):
  print（"hon")
elif (s[-1]==0,1,6,8):
  print("pon")
else:
  print("bon")


### FIXED CODE ###

s = input()
if (s[-1]=="2" or s[-1]=="4" or s[-1]=="5" or s[-1]=="7" or s[-1]=="9"):
  print("hon")
elif (s[-1]=="0" or s[-1]=="1" or s[-1]=="6" or s[-1]=="8"):
  print("pon")
else:
  print("bon")
import math
n = input()
print ( (n //2) + 1)


### FIXED CODE ###

n = int(input())
w = -(-n // 2)
ans = w/n
print(ans)
x, n = map(int, input().split())
if n > 1:
  p = list(map(int, input().split()))
else:
  print(x)
  exit(0)
   
for i in range(n+1):
  if (x-i) not in p:
    print(x-i)
    break
  if (x+i) not in p:
    print(x+i)
    break

### FIXED CODE ###

x = input().split()
print(x.index('0') + 1)
in_rating = 0
N = int(input())
K = int(input())

if n >= 10:
  in_rating = K
  print(K)
else:
  in_rating = K + 100(100-K)
  

### FIXED CODE ###

n,r=map(int,input().split())

if n >= 10:
  print(r)
else:
	in_rate = r + 100 * (10-n)
	print(in_rate)
n = int(input())
a = list(map(int, input().split()))
ans = None
for i in a:
  if a.find(i) != -1:
    ans = 'NO'
    break
else:
  ans = 'YES'
print(ans)
  

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
a.sort()
ans = None
for i in range(len(a) - 1):
  if a[i] == a[i + 1]:
    ans = 'NO'
    break
else:
  ans = 'YES'
print(ans)
input()
A=[0]+list(map(int,input().split()))
H=len(A)
def h(i):
 l=2*i;r,g=l+1,[i,l][A[i]<A[l]and l<H]
 if A[g]<A[r]and r<H:g=r
 if g!=i:A[i],A[g]=A[g],A[i];h(g)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))


### FIXED CODE ###

H=int(input())+1
A=[0]+list(map(int,input().split()))
def s(x,y):A[x],A[y]=A[y],A[x];h(y)
def h(i):
 l=2*i;r=l+1
 if r<H:
  if A[i]<A[l]:
   if A[l]<A[r]:s(i,r)
   else:s(i,l)
  elif A[i]<A[r]:s(i,r)
 elif l<H and A[i]<A[l]:s(i,l)
for i in range(H//2,0,-1):h(i)
print(' '+' '.join(map(str,A[1:])))
x = map(int,input().split())

num = 0

for i in range(5):
	num += 1
    if x[i] == 0:
      break

print(num)

### FIXED CODE ###

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

num = 0

for i in range(5):
	num += 1
	if x[i] == 0:
		break
        
print(num)
import sys
k=int(input())
str_n =input().split()
n=list(map(int,str_n))
a=[]
for i in range(k-1,-1,-1):
    a.append(n[i])
for i in a:
    if i != a[k-1]:
        print(str(i)+' ', end="")
    else:
        print(str(i))
     

### FIXED CODE ###

raw_input()
l = raw_input().split()
l.reverse()
print " ".join(l)
N, M = map(int, input().split())
edge = []
for i in range(M):
    a,b,c = map(int, input().split())
    edge.append((a-1,b-1, c))
point = [None] * N
point[0] = 0
for i in range(N):
    for a,b,c in edge:
        if point[a] is not None:
            if point[b] is None:
                point[b] = point[a] + c
            point[b] = max(point[b], point[a] + c)
current_point = point[N-1]
for a,b,c in edge:
    if point[a] is not None:
        if point[b] is None:
            point[b] = point[a] + c
    point[b] = max(point[b], point[a] + c)
if current_point < point[N-1]:
    print("inf")
else:
    print(current_point)


### FIXED CODE ###

N, M = map(int, input().split())
edge = []
for i in range(M):
    a,b,c = map(int, input().split())
    edge.append((a-1,b-1, c))
point = [None] * N
point[0] = 0
for i in range((N*4)//3):
    for a,b,c in edge:
        if point[a] is not None:
            if point[b] is None:
                point[b] = point[a] + c
            point[b] = max(point[b], point[a] + c)
current_point = point[N-1]
for i in range(5):
    for a,b,c in edge:
        if point[a] is not None:
            if point[b] is None:
                point[b] = point[a] + c
            point[b] = max(point[b], point[a] + c)
if current_point < point[N-1]:
    print("inf")
else:
    print(current_point)
N,K=map(int,input().split())
A=map(int,input().split())
maxvalue=0
for i in range(N-K):
  maxvalue=max(maxvalue,sum(A[K:N+K]))
print(maxvalue)

### FIXED CODE ###

N,K=map(int,input().split())
A=list(map(int,input().split()))
summation=[0,A[0]]
for i in range(1,N):
  summation.append(summation[i]+A[i])

maxvalue=summation[K]
for i in range(1,1+N-K):
  maxvalue=max(maxvalue,summation[i+K]-summation[i])
print((maxvalue+K)/2)
a,b=map(int,input().split())
if a<b
 print('a<b')
 elif a>b
 print('a>b')
 elif a==b
 print('a==b')

### FIXED CODE ###

a, b = map(int,input().split())
 
if a > b:
    print('a > b')
elif a < b:
    print('a < b')
else:
    print('a == b')
s = sorted(list(map(str, input().split(""))))
t = sorted(list(map(str, input().split("")))).reverse()
print("Yes" if s < t else "No")


### FIXED CODE ###

s = sorted(input())
t = sorted(input())[:: -1]
print("Yes" if s < t else "No")
s,w=int(input().split())
if w>=s:
  print('unsafe')
else:
  print('safe')

### FIXED CODE ###

s,w=map(int,input().split())
if w>=s:
  print('unsafe')
else:
  print('safe')
from fractions import gcd
from functools import reduce
import numpy as np
import math

N, M = map(int, input().split())
a = np.array(list(map(int, input().split()))) / 2
a = np.array(list(set(a)))

def lcm(a, b):
    return a * b / gcd(a, b)
    
def check_two(num):
    count = 0
    while num % 2 == 0:
        num /= 2
        count += 1
    return count

two_nums = [check_two(i) for i in a]
if len(set(two_nums)) > 1:
    print(0)
    exit()

lcm = lcm(a[0], a[1])
for i in range(2, len(a)):
    lcm = lcm(lcm, a[i])
    if lcm > N:
        print(0)
        exit()
    
ans = M // lcm
print(math.ceil(ans / 2))

### FIXED CODE ###

import fractions
import math
 
N, M = map(int, input().split())
a = list(map(int, input().split()))
a = [i // 2 for i in a]
 
def lcm(a, b):
    return a * b // fractions.gcd(a, b)
    
def check_two(num):
    count = 0
    while num % 2 == 0:
        num //= 2
        count += 1
    return count

two_num = check_two(a[0])

for i in range(1, len(a)):
    if two_num != check_two(a[i]):
        print(0)
        exit()
 
my_lcm = a[0]
for i in range(1, len(a)):
    my_lcm = lcm(my_lcm, a[i])
    if my_lcm > M:
        print(0)
        exit()
    
ans = M // my_lcm
print(math.ceil(ans / 2))
def main():
    N = int(input())
    X = [int(x) for x in input().split()]
    ans = []
    for i in range(min(X), max(X)):
        a = map(lambda x: (x-i)**2, X)
        ans.append(sum(a))
    return print(min(ans))


if __name__ == "__main__":
    main()


### FIXED CODE ###

def main():
    N = int(input())
    X = [int(x) for x in input().split()]
    ans = []
    mini = min(X)
    maxi = max(X)
    if mini != maxi:
        for i in range(mini, maxi):
            a = map(lambda x: (x-i)**2, X)
            ans.append(sum(a))
    else:
        ans.append(0)
    return print(min(ans))


if __name__ == "__main__":
    main()
n=int(input())
 odd=(n+1)//2
 print(odd/n)

### FIXED CODE ###

n=int(input())
odd=(n+1)//2
print(odd/n)
s=input()
divide=["dream","erase","eraser","dreamer"]
#全探索する
def dfs(n):
        if n==len(s):#最後まで行ったらtrue
                return True
        for i in divide:
                if n+len(i)<=len(s) and "".join(s[n:n+len(i)])==i:
                        if dfs(n+len(i)):
                                return True
        return False
print("YES") if dfs(0) else print("NO")


### FIXED CODE ###

s=input().replace("eraser",",").replace("erase",",").replace("dreamer",",").replace("dream",",").replace(",","")
print("YES" if s=="" else "NO")
import sys


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


def input():
    return sys.stdin.readline().strip()


def main():
    A, B, N = map(int, input().split())

    def func(x):
        res = (A * x) // B - A * (x // B)
        return res

    M = 0
    for i in range(N, max(0, N - 10 ** 8), -1):
        tmp = func(i)
        print(i, tmp)
        if tmp > M:
            M = tmp

    print(M)


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys


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


def input():
    return sys.stdin.readline().strip()


def main():
    A, B, N = map(int, input().split())

    def func(x):
        res = (A * x) // B - A * (x // B)
        return res

    print(func(min(N, B - 1)))


if __name__ == "__main__":
    main()
a,b = map(int, raw_input().split())
print(a*b,(a+b)*2)


### FIXED CODE ###

a,b = map(int, input().split())
print(str(a*b)+" "+str(2*(a+b)))
N, Y = map(int, input().split())
result = False
count_10000 = 0
count_5000 = 0
count_1000 = 0

for count_10000 in range(0, N+1):
    for count_5000 in range(0, N+1):
        for count_1000 in range(0, N+1):
            total = count_10000 * 10000 + count_5000 * 5000 + count_1000 * 1000
            count = count_10000 + count_5000 + count_1000
            if total == Y and count == N:
                result = True
                break
        else:
            continue
        break
    else:
        continue
    break

if result:
    print(f"{count_10000} {count_5000} {count_1000}")
else:
    print("-1 -1 -1")


### FIXED CODE ###

input_data = input()
N, Y = map(int, input_data.split())
result = False
count_10000 = 0
count_5000 = 0
count_1000 = 0

for count_10000 in range(0, N + 1):
    for count_5000 in range(0, N + 1 - count_10000):
        count_1000 = N - count_10000 - count_5000
        total = count_10000 * 10000 + count_5000 * 5000 + count_1000 * 1000
        count = count_10000 + count_5000 + count_1000
        if total == Y and count == N:
            result = True
            break
    else:
        continue
    break

if result:
    print("{} {} {}".format(count_10000, count_5000, count_1000))
else:
    print("-1 -1 -1")
A = input()
B = input()
C = input()
a_len = len(A)
b_len = len(B)
c_len = len(C)
next = "A"

while a_len>=0 and b_len>=0 and c_len>=0:
    if next=="A":
        next = A[0].upper()
        A = A.pop(0)
        a_len = a_len - 1
    elif next=="B":
        next = B[0].upper()
        A = A.pop(0)
        b_len = b_len - 1
    else:
        next = C[0].upper()
        B = B.pop(0)
        c_len = c_len - 1
print(next)

### FIXED CODE ###

A = list(str(input()))
B = list(str(input()))
C = list(str(input()))
a_len = len(A)
b_len = len(B)
c_len = len(C)
next = "a"

while a_len>=0 and b_len>=0 and c_len>=0:
    if next=="a":
        if a_len>=1:
            next = A[0]
            del A[0]
        a_len -= 1
    elif next=="b":
        if b_len>=1:
            next = B[0]
            del B[0]
        b_len -= 1
    else:
        if c_len>=1:
            next = C[0]
            del C[0]
        c_len -= 1
print(next.upper())
n,m=map(int,input().split())
s=input()
s=s[:m]+chr(ord(s[m])-ord('A')+ord('a'))+s[m+1:]
print(s)

### FIXED CODE ###

n,m=map(int,input().split())
s=input()
s=s[:m-1]+chr(ord(s[m-1])-ord('A')+ord('a'))+s[m:]
print(s)
string = input()

pairs = 0
limit = len(string)-3
secondLimit
for i in range(limit):
  substring += string[i]
  for j in range(i+1,secondLimit):
    substring += string[j]
    if j-i > 3 and int(substring) % 673 == 0:
      n += 1
  substring = ''
print(n)

### FIXED CODE ###

number = str(input())[::-1]
remainderDictionary = {0: 1}
    
sum = 0
x = 1
for i in number:
  x = (x * 10) % 2019
  sum += int(i) * x
  sum %= 2019
  remainderValue = remainderDictionary.get(sum,0) + 1
  remainderDictionary[sum] = remainderValue
     
ans = 0
for i in remainderDictionary:
  value = remainderDictionary[i]
  ans += value * (value - 1) // 2 # N C 2
print(ans)
n = input()
for i in range(n):
    t, x, y = map(int, input().split())
    if x + y <= t or (x+y-t)%2 /= 0
        print("No")
        exit()
print("Yes")

### FIXED CODE ###

n = int(input())
ti=0
xi=0
yi=0
for i in range(n):
    t, x, y = map(int, input().split())
    if abs(x-xi) + abs(y-yi) > abs(t-ti) or (abs(x-xi) + abs(y-yi) + abs(t-ti)) % 2 != 0:
        print("No")
        exit()
    ti=t
    xi=x
    yi=y
print("Yes")
N = input()

S = raw_input()
sample = [i for i in S]

i = 0
while i < len(sample)-1:
    if sample[i] == '(' and sample[i+1] == ')':
        del sample[i],sample[i+1]
        i = 0
    i += 1

S = '('*sample.count(')')+S+')'*sample.count('(')
print S

### FIXED CODE ###

N = input()

S = raw_input()
sample = [i for i in S]

i = 0
while i < len(sample)-1:
    if sample[i] == '(' and sample[i+1] == ')':
        del sample[i],sample[i]
        i = -1
    i += 1

S = '('*sample.count(')')+S+')'*sample.count('(')
print S
#
# abc157 c
#
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """3 3
1 7
3 2
1 7"""
        output = """702"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """3 2
2 1
2 3"""
        output = """-1"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """3 1
1 0"""
        output = """-1"""
        self.assertIO(input, output)


def resolve():
    N, M = map(int, input().split())
    SC = [list(map(int, input().split())) for _ in range(M)]
    SC = set(map(tuple, SC))
    SC = list(set(SC))
    SC.sort()

    ans = -1
    if M == 0:
        ans = 10(N-1) 
    else:
        for i in range(10**(N-1), 10**N):
            si = str(i)
            for sc in SC:
                s, c = sc
                if si[s-1] != str(c):
                    break
            else:
                ans = i
                break

    print(ans)


if __name__ == "__main__":
    # unittest.main()
    resolve()


### FIXED CODE ###

#
# abc157 c
#
import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """3 3
1 7
3 2
1 7"""
        output = """702"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """3 2
2 1
2 3"""
        output = """-1"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """3 1
1 0"""
        output = """-1"""
        self.assertIO(input, output)


def resolve():
    N, M = map(int, input().split())
    SC = [list(map(int, input().split())) for _ in range(M)]
    SC = set(map(tuple, SC))
    SC = list(set(SC))
    SC.sort()

    ans = -1
    for i in range(10**N):
        si = str(i)
        if len(si) != N:
            continue
        for sc in SC:
            s, c = sc
            if si[s-1] != str(c):
                break
        else:
            ans = i
            break

    print(ans)


if __name__ == "__main__":
    # unittest.main()
    resolve()
N = int(input())
reds = []
for i in range(N):
    reds.append(tuple(map(int, input().split(" "))))
blues = []
for i in range(N):
    blues.append(tuple(map(int, input().split(" "))))
reds.sort(key=lambda x: x.reverse(), reverse=True)
blues.sort()
picked = [False for _ in range(N)]
ans = 0
for blue in blues:
    for i, red in enumerate(reds):
        if blue[0] > red[0] and blue[1] > red[1] and not picked:
            ans += 1
            picked[i] = True
            break
print(ans)

### FIXED CODE ###

from pprint import pprint
N = int(input())
reds = []
for i in range(N):
    reds.append(tuple(map(int, input().split(" "))))
blues = []
for i in range(N):
    blues.append(tuple(map(int, input().split(" "))))
reds.sort(key=lambda x: (x[1], x[0]), reverse=True)
blues.sort()
picked = [False for _ in range(N)]
ans = 0
for blue in blues:
    for i, red in enumerate(reds):
        if blue[0] > red[0] and blue[1] > red[1] and not picked[i]:
            ans += 1
            picked[i] = True
            break
print(ans)
N = int(input())
import math
U = math.ceil(3*N/4)
D = math.ceil(N/4)
if N % 2 == 0:
  print(N,N,N//2)
else:
  if D%2 == 1:
    D += 1
  h = -1
  for n in range(D,3500):
    if h > 0:
      break
    for w in range(n,3500):
      #print(h,n,w)
      if w*n*N/(4*n*w-w*N-n*N) == int(w*n*N/(4*n*w-w*N-n*N)):
        h = w*n*N//(4*n*w-w*N-n*N)
        ans = (w*n*N//(4*n*w-w*N-n*N),n,w)
        break
        
print(ans)

### FIXED CODE ###

N = int(input())
import math
U = math.ceil(3*N/4)
D = math.ceil(N/4)
if N % 2 == 0:
  ans = (N,N,N//2)
else:
  if D%2 == 1:
    D += 1
  h = -1
  for n in range(D,3500):
    if h > 0:
      break
    for w in range(n,3500):
      #print(h,n,w)
      if w*n*N/(4*n*w-w*N-n*N) == int(w*n*N/(4*n*w-w*N-n*N)):
        h = w*n*N//(4*n*w-w*N-n*N)
        ans = (w*n*N//(4*n*w-w*N-n*N),n,w)
        break
        
print(*ans)
def fibo(f1, f2, count):

        if count == 2:
            return f1 + f2

    return fibo(f2, f1+f2, count-1)

n = int(raw_input())

print fibo(1, 1, n)

### FIXED CODE ###

n=input()

fn_first=1
fn_second=1

if n >= 2:
    for x in xrange(n-1):
        tmp = fn_first
        fn_first = fn_first + fn_second
        fn_second = tmp

print fn_first
a = int(input())
blue = []
count = []
for i in range(a)
    x = input()
    if x in blue:
        count[blue.index(x)] += 1
    else:
        blue.append(x)
        count.append(1)
b = int(input())
for i in range(b)
    x = input()
    if x in blue:
        count[blue.index(x)] -= 1
    else:
        blue.append(x)
        count.append(-1)

blue.sorted()
if blue[0] < 0:
    print("0")
else:
    print(blue[0])

### FIXED CODE ###

a = int(input())
blue = []
count = []
for i in range(a):
    x = input()
    if x in blue:
        count[blue.index(x)] += 1
    else:
        blue.append(x)
        count.append(1)
b = int(input())
for i in range(b):
    x = input()
    if x in blue:
        count[blue.index(x)] -= 1
    else:
        blue.append(x)
        count.append(-1)

count.sort()
count.reverse()
if count[0] < 0:
    print("0")
else:
    print (count[0])