Harryxun/stf_run huggingface dataset:
import math
from functools import reduce

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

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

N = int(input())

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


print(gcd_list(a))

import math
from functools import reduce

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

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

N = int(input())

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


print(gcd_list(a))

### FIXED CODE ###

import fractions
from functools import reduce

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

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

N = int(input())

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


print(gcd_list(a))
n = int(input())
l = list(map(int,input().split()))
cnt = 0
l.sort()

for i in range(n):
    for j in range(i+1,n):
        k = bisect.bisect_left(l,l[i]+l[j])
        if k > j:
            cnt += k - j - 1
        else:
            continue
            
print(cnt)

### FIXED CODE ###

import bisect
n = int(input())
l = list(map(int,input().split()))
cnt = 0
l.sort()

for i in range(n):
    for j in range(i+1,n):
        k = bisect.bisect_left(l,l[i]+l[j])
        if k > j:
            cnt += k - j - 1
        else:
            pass
            
print(cnt)
N,A = int(input().split())
B = N * N - A
print(B)

### FIXED CODE ###

# N,A = map(int, input().split())
N = int(input())
A = int(input())
B = N * N - A
print(B)
N,X = map(int,input().split())
bound_limit= N+1
L = list(map(int,input().split()))
sum=0
count=1
for i in range(len(L)):
  sum+=L[i]
  if sum<=x:
    count+=1
  else:
    break
print(count)

### FIXED CODE ###

N,X = map(int,input().split())
bound_limit= N+1
L = list(map(int,input().split()))
sum=0
count=1
for i in range(0,len(L)):
  sum+=L[i]
  if sum<=X:
    count+=1
  else:
    break
print(count)
n=input()
print(1000-(int(n[1:4])))

### FIXED CODE ###

n=int(input())
print((1000-n%1000)%1000)
4 2000

### FIXED CODE ###

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

t = N*500
if t >= K:
    print("Yes")
else:
    print("No")
A = input()
B = input()
C = input()

xa = 0
xb = 0
xc = 0

#配列の次のカードの文字を返す
def next(X, i):
    if X[i - 1] == 'a':
        return A[xa]
    elif X[i - 1] == 'b':
        return B[xb]
    else:
        return C[xc]

h = 'A'
xa += 1
k = next(A, xa) #最初

while True:
    if k == 'a':
        h = 'A'
        xa += 1
        if xa <= len(A):
            k = next(A, xa)
        else:
            break
    elif k == 'b':
        h = 'B'
        xb += 1
        if xb <= len(B):
            k = next(B, xb)
        else:
            break
    else:
        h = 'C'
        xc += 1
        if xc <= len(C):
            k = next(C, xc)
        else:
            break

print(h)


### FIXED CODE ###

A = input()
B = input()
C = input()

xa = 0
xb = 0
xc = 0

h = 'A'
k = A[0] #最初の１枚を抜く
xa += 1

while True:

    if k == 'a':
        h = 'A'
        if xa < len(A):
            k = A[xa]
            xa += 1
        else:
            break
    elif k == 'b':
        h = 'B'
        xb += 1
        if xb < len(B):
            k = B[xb]
            xb += 1
        else:
            break
    elif k == 'c':
        h = 'C'
        xc += 1
        if xc < len(C):
            k = C[xc]
            xc += 1
        else:
            break

print(h)
a,b,c=map(int,input().split())
ans='NO'
A=[]
for i in range(10001):
    A.append((a*i-c)%b)
    if(i>3)and(A[0]==A[-1]):
      break
    if (a*i-c)%b==0:
        ans='YES'
        break
print(ans)


### FIXED CODE ###

A,B,C= map(str,input().split())
if(A[-1]==B[0])and(B[-1]==C[0]):
  print("YES")
else:
  print("NO")
a , b, c = map(int, input().split())
X = []
for i in range(max(a,b)):
  if a % i == 0 and b % i == 0:
    X.append(i)
print(X[c])

### FIXED CODE ###

a , b, c = map(int, input().split())
X = []
for i in range(min([a,b])):
  if a % (i+1) == 0 and b % (i+1) == 0:
    X.append((i+1))
print(X[-c])
def main():
  N, M = list(map(int, input().split(' ')))

  root = [[] for i in range(M+1)]
  for i in range(M):
    A, B = list(map(int, input().split(' ')))
    root[A].append(B)
    root[B].append(A)

  mitisurube = [-1 for i in range(N+1)]
  done = {}
  next_ = [1]
  #cost[1] = 0

  while next_:
    now_pos = next_.pop(0)
    for next_pos in root[now_pos]:
      try:
        a = done[next_pos]
      except KeyError:
        #cost[next_pos] = cost[now_pos] + 1
        mitisurube[next_pos] = now_pos
        next_.append(next_pos)
        done[next_pos] = 1
  #print('root')
  #print(*root)
  #print('cost')
  #print(*cost)
  #print('mitisirube')
  if mitisurube.count(-1) < 3:
    print('Yes')
    print(*mitisurube[2:], sep='\n')
  else:
    print('No')

if __name__ == '__main__':
  main()

### FIXED CODE ###

from collections import deque

def main():
  N, M = list(map(int, input().split(' ')))

  root = [[] for i in range(N+1)]
  for i in range(M):
    A, B = list(map(int, input().split(' ')))
    root[A].append(B)
    root[B].append(A)

  mitisurube = [-1 for i in range(N+1)]
  next_ = deque()
  next_.append(1)

  while next_:
    now_pos = next_.popleft()
    for next_pos in root[now_pos]:
      if mitisurube[next_pos] == -1:
        mitisurube[next_pos] = now_pos
        next_.append(next_pos)
  #print('root')
  #print(*root)
  #print('mitisirube')
  print('Yes')
  print(*mitisurube[2:], sep='\n')

if __name__ == '__main__':
  main()
N, Q = map(int, input().split())
s = '#' + input() + '#'
#room[0], [1~N], [N+1]と考える
#文字を取り出すとき:[1~N]
T = [] #Title[0～Q-1]
D = [] #Direction[0～Q-1] R:1, L:-1で表現
for t, d in [input().split() for _ in range(Q)]:
  T.append(t)
  D.append(-1 if d=='L' else 1)

#そのゴーレムがどちらかの端にたどり着けるかの関数
#True, Falseを返す
def canReachEnd(iL, dir):
  #iLは初期マス(1~N), dirは方向(L:-1, R:1)
  
  #nowL:今いるマスの位置
  nowL = iL
  #nowt:今いるマスに書いてある文字
  nowt = s[iL]
  for t, d in zip(T, D):
    print('nowtは'+str(nowt)+'で,'+str(t)+str(d))
    if t == nowt:
      #左に動いても右に動いてもdを足せばok
      #端に落ちたら文字が'#'なので気にしない
      nowL += d
      nowt = s[nowL]
      print('moved' + str(d) + ',' + str(nowL) + 'to:' + str(nowt))
      
  if dir == 1 and nowL == N+1:
    return True
  elif dir == -1 and nowL == 0:
    return True
  else: return False
#たどり着けるかの関数終わり

#まずは左側 room0に辿り着くかどうかの判定
#二分探索
  
print(canReachEnd(10,1))

### FIXED CODE ###

N, Q = map(int, input().split())
s = '#' + input() + '#'
#room[0], [1~N], [N+1]と考える
#文字を取り出すとき:[1~N]
T = [] #Title[0～Q-1]
D = [] #Direction[0～Q-1] R:1, L:-1で表現
for t, d in [input().split() for _ in range(Q)]:
  T.append(t)
  D.append(-1 if d=='L' else 1)

#そのゴーレムがどちらかの端にたどり着けるかの関数
#True, Falseを返す
def canReachEnd(iL, dir):
  #iLは初期マス(1~N), dirは方向(L:-1, R:1)
  
  #nowL:今いるマスの位置
  nowL = iL
  #nowt:今いるマスに書いてある文字
  nowt = s[iL]
  for t, d in zip(T, D):
    if t == nowt:
      #左に動いても右に動いてもdを足せばok
      #端に落ちたら文字が'#'なので気にしない
      nowL += d
      nowt = s[nowL]
      
  if dir == 1 and nowL == N+1:
    return True
  elif dir == -1 and nowL == 0:
    return True
  else: return False
#たどり着けるかの関数終わり

#ここから二分探索で2つの「境目」を探す

#(1)「iは左に辿り着くがi+1は辿り着かない」iを探す
#何も辿り着かない場合はi=0とする？
#全部辿り着く場合はi=Nとする？
#leftとrightが隣接したときのleftを答えとする？
##すると、ありえるleftの範囲は0~N
left = 0
right = N+1
while right > left+1:
  check = (left+right)//2
  
  if canReachEnd(check, -1):left = check
  else: right = check
#答えを代入
leftborder = left


#(2)「jは右に辿り着くがj-1は辿り着かない」jを探す
#何も辿り着かない場合はj=N+1とする？
#全部辿り着く場合はj=1とする？
#leftとrightが隣接したときのrightを答えとする？
##すると、ありえるrightの範囲はleftborder+1~N+1
left = leftborder #(1)で左に辿り着くと分かった部分は省く
right = N+1
while right > left+1:
  check = (left+right)//2
  
  if canReachEnd(check, 1):right = check
  else: left = check
#答えを代入
rightborder = right

#二分探索終わり

#lbには左に辿り着く限界,rbには右に辿り着く限界が格納
#1~lbまでは全部左端に落ちる lb==0なら0
#rb~Nまでは全部右端に落ちる rb==N+1なら0

dropcnt = 0
dropcnt += leftborder
dropcnt += (N-(rightborder-1))
print(N-dropcnt)
n=int(input())
s = [input() for i in range(n)]
c=0
a=["" for i in range(n)]
for i in range(n):
   b[i]=sorted(s[i])
   a[i]=''.join(b[i])

for i in range(n-1):
    for j in range(i+1,n):
        if a[i]==a[j]:
            c+=1
print(c)

### FIXED CODE ###

N = int(input())
S = [''.join(sorted(input().rstrip())) for _ in range(N)]
 
from collections import Counter
counter = Counter(S)
 
answer = sum(x*(x-1)//2 for x in counter.values())
print(answer)
s = input()
a = s[::2].count(0) + s[1::2].count(1)
b = s[::2].count(1) + s[1::2].count(0)
print(min(a, b)

### FIXED CODE ###

s = input()
a = s[::2].count('0') + s[1::2].count('1')
b = s[::2].count('1') + s[1::2].count('0')
print(min(a, b))
def main():
    N = int(input())
    NUM = list(str(N))
    for i in NUM:
        if int(i) == 7:
            print("Yes")
            exit(1)
    print("No")


main()

### FIXED CODE ###

def main(): # A162
    N = int(input())
    NUM = list(str(N))
    NUM = list(map(int,NUM))
    #A = list(map(int, input().split()))  # [1,2,3,4,5]
    for i in NUM:
        if int(i) == 7:
            print("Yes")
            exit(0)
    print("No")
    
main()
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
cnt = 26 * [0]
Input = ""
loop = True

while loop:
    I = input()
    for i in I:
        if i == '.':
            loop = False
    Input += I

for i1 in range(len(alphabet)):
    for i2 in range(len(Input)):
        if 'A' <= Input[i2] <= 'Z':
            w = Input[i2].lower()
        else:
            w = Input[i2]
        if alphabet[i1] == w:
            cnt[i1] += 1
    print(alphabet[i1] + " : " + str(cnt[i1]))

### FIXED CODE ###

import sys

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
cnt = 26 * [0]
Input = ""
loop = True

for I in sys.stdin:
    Input += I

for i1 in range(len(alphabet)):
    for i2 in range(len(Input)):
        if 'A' <= Input[i2] <= 'Z':
            w = Input[i2].lower()
        else:
            w = Input[i2]
        if alphabet[i1] == w:
            cnt[i1] += 1
    print(alphabet[i1] + " : " + str(cnt[i1]))
def main():
    x = 99
    print(x ** 3+'?\n')

if __name__ == "__main"
    main()

### FIXED CODE ###

x=int(input())
print(x**3)
s=input()
print(s.count("+")-s.count("-")

### FIXED CODE ###

s=input()
print(s.count("+")-s.count("-"))
from collections import defaultdict

class Tree:
  def __init__(self):
    self.edges = defaultdict(set)
  
  def add(self, x, y, w):
    self.edges[x].add((y, w))
    self.edges[y].add((x, w))
  
  def traverse(self, start):
    return self._traverse(start, 0, set([start]))
  
  def _traverse(self, start, dist, already_visited):
    out_nodes = self.edges[start]
    for out_node, w in out_nodes:
      if out_node in already_visited:
        continue
      new_dist = dist + w
      yield (out_node, new_dist)
      already_visited.add(out_node)
      for res in self._traverse(out_node, new_dist, already_visited):
        yield res
      
n = int(input())
tree = Tree()
for _ in range(n-1):
  xyw = list(map(int, input().split()))
  tree.add(*xyw)

start = 1
node_dists = list(tree.traverse(start))
node_dists.append((start, 0))
node_dists = sorted(node_dists, key=lambda x: x[0])

for node, dist in node_dists:
  print(1 if dist % 2 == 0 else 0)

### FIXED CODE ###

#!/usr/bin/env python
import bisect
from collections import defaultdict
import math

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

    edges = defaultdict(list)
    for _ in range(N-1):
        u, v, w = map(int, input().split())
        edges[u-1].append((v-1, w))
        edges[v-1].append((u-1, w))

    colors = [None]*N
    colors[0] = 0
    colored = [(0, 0)]
    while colored:
        new_colored = []
        for n, d in colored:
            nodes = edges[n]
            for m, w in nodes:
                if colors[m] is None:
                    dist = d + w
                    if dist % 2 == 0:
                        colors[m] = 0
                    else:
                        colors[m] = 1
                    new_colored.append((m, dist))
        colored = new_colored

    for n in range(N):
        print(colors[n])

if __name__ == '__main__':
    main()
input(D)
input(T)
input(S)

if T*S>=D:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

a=list(map(int,input().split()))
D=a[0]
T=a[1]
S=a[2]
if T*S>=D:
  print('Yes')
else:
  print('No')
s = input
print("TBD") if int(s[5:7]) =>5 else print("Heisei")

### FIXED CODE ###

s=input()

if int(s[5:7]) <= 4:
    print('Heisei')
else:
    print('TBD')
N = int(input())
ans = 0

for i in range(1, N + 1):
    if i % 2 == 1:
        count = 0
        for j in range(1, i + 1, 2):
            if i % j == 0:
                count += 1
        if count == 8:
            ans += 1

print(ans)

### FIXED CODE ###

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

print((a-1)*(b-1))
# 問題文：長さNの偶数からなる正の整数列A=a1,a2,...,aNと、整数Mが与えられます。
#        任意のk(1≤k≤N)に対して以下の条件を満たす正の整数XをAの「半公倍数」と定義します。
#        X=ak×(p+0.5)を満たす負でない整数pが存在する。
#        1以上M以下の整数のうちのAの半公倍数の個数を求めてください。
# 入力 : 以下の形式で標準入力から与えられる。
#       N M
#       a1 a2 ... aN
# 出力 : 1 以上 M 以下の整数のうちの A の半公倍数の個数を出力せよ。

# 最小半公倍数を求める
def min_hankobaisu(A, M):
    result = 1
    for a in A:
        result = result * a / 2
        if result > M:
            print(0)
            exit(0)
    return int(result)

# 正の整数列Aの長さN, 半公倍数の上限M
N, M = map(int, input().split())

# 正の整数列A
A = list(set(list(map(int, input().split()))))
A.sort(reverse=True)
# hankobaisu_list = []

# 与えられた数値が2*奇数と2*偶数なのであれば半公倍数はない
# → その場で終了
for i in range(0, len(A) - 1):
    if (A[i] / 2 % 2) != (A[i + 1] / 2 % 2):
        print(0)
        exit(0)

# A[i] が2*偶数の場合はだめ？
if (A[0] / 2) % 2 == 0:
    print(0)
    exit(0)

# 半公倍数の最小値を求める
min_hankobaisu = min_hankobaisu(A, M)
#print('最小半公倍数：{}'.format(min_hankobaisu))
print(int(M/min_hankobaisu+1)/2)



### FIXED CODE ###

# 問題文： 大きさ N の順列 ((1, 2, ..., N) を並び替えてできる数列) P, Q があります。大きさ N の順列は N! 通り考えられます。
#         このうち、P が辞書順で a 番目に小さく、Q が辞書順で b 番目に小さいとして、|a−b| を求めてください。
# 注記： 2 つの数列 X, Y について、ある整数 k が存在して Xi=Yi (1≤i<k) かつ Xk<Yk が成り立つとき、X は Y より辞書順で小さいと定義されます。
# 制約: 2≤N≤8　P,Qは大きさNの順列である。入力は全て整数である。

import math

# 数列が何番目かを返却するメソッド
def junban(N, str):
    int_N = int(N)
    int_list = str.split() # 入力文字を配列化
    int_list = [int(i) for i in int_list]
    yet_list = str.split() # まだ出てきていない数字のリスト
    yet_list = [int(i) for i in yet_list]

    num = 1 # 何番目か保持する
    keta = 0 # 上から何桁目か保持する

    while keta < (int_N):
        # 該当桁の数字を確保する
        now_int = int_list[keta]

        # 未出数値のリストを更新する
        yet_list.remove(now_int)

        # 該当桁以下の階乗
   #     print('該当桁以下の桁数は：{}'.format(len(yet_list)))
        # 該当桁の数字より若い数字がいくつ残っているか
    #    print('該当桁の数字より若い数字はあと{}個'.format(len([i for i in yet_list if i < now_int])))

        # 順番をカウント
        # 該当桁以下の階乗 * 未出数値の内、現在より数値の小さいものの個数
        num += math.factorial(len(yet_list)) * len([i for i in yet_list if i < now_int])
        keta += 1

#    print('{}番目'.format(num))
    return num

# 大きさNを受け取る
N = input()
# 数列Pを受け取る
P = input()
# 数列Qを受け取る
Q = input()

# Pが何番目か求める
p_int = junban(N, P)
q_int = junban(N, Q)

print(abs(p_int - q_int))
n = int(input())
arr = list(int,input().split())
lst = filter(i%2==1,arr[::2])
print(len(lst))

### FIXED CODE ###

n = int(input())
arr = list(map(int,input().split()))
def odd(n) : return (n%2==1)
lst = list(filter(odd,arr[0:n:2]))
print(len(lst))
import sys
input = sys.stdin.readline

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

OK=10**9
NG=-1

while OK-NG>1:
    mid=(OK+NG)//2

    ANS=0
    for a in A:
        ANS+=(a-0.01)//mid

    if ANS<=K:
        OK=mid
    else:
        NG=mid
print(OK)


### FIXED CODE ###

import sys
input = sys.stdin.readline

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

OK=10**9
NG=0

while OK-NG>1:
    mid=(OK+NG)//2

    ANS=0
    for a in A:
        ANS+=(a-0.01)//mid

    if ANS<=K:
        OK=mid
    else:
        NG=mid
print(OK)
a,p=map(int,inputy().split())
print((3*a+p)//2)


### FIXED CODE ###

a,p=map(int,input().split())
print((3*a+p)//2)
a,b = int(input().split())
S = a*b
L = 2*(a+b)
print(x y)

### FIXED CODE ###

a,b = map(int,input().split())
S = a*b
L = 2*(a+b)
print(S,end=" ")
print(L)
import sys
def input(): return sys.stdin.readline().rstrip()

def main():
    H, W, K = map(int, input().split())
    S = [input() for _ in range(H)]

    ans = 10 ** 9

    for bit in range(1 << (H-1)):
        canSolve = True
        ord = [0] * H
        N = 0
        for i in range(H):
            if bit & 1 << i:
                ord[i+1] = ord[i] + 1
                N += 1
            else:
                ord[i+1] = ord[i]
        nums = [0] * H
        for w in range(W):
            one = [0] * H
            overK = False
            for h in range(H):
                one[ord[h]] += int(S[h][w])
                nums[ord[h]] += int(S[h][w])
                if one[ord[h]] > K:
                    canSolve = False
                if nums[ord[h]] > K:
                    overK = True
            if not canSolve:
                break
            if overK:
                N += 1
                nums = one
        if canSolve and ans > N:
            ans = N
    print(ans)

if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
from collections import defaultdict
def input(): return sys.stdin.readline().rstrip()

def main():
    H, W, K = map(int, input().split())
    S = [input() for _ in range(H)]

    ans = 10 ** 9

    for bit in range(1 << (H-1)):
        canSolve = True
        ord = defaultdict(int)
        N = 0
        for i in range(H):
            if bit & 1 << i:
                ord[i+1] = ord[i] + 1
                N += 1
            else:
                ord[i+1] = ord[i]
        add = 0
        nums = defaultdict(int)
        for w in range(W):
            one = defaultdict(int)
            ok = True
            for h in range(H):
                one[ord[h]] += int(S[h][w])
                nums[ord[h]] += int(S[h][w])
                if one[ord[h]] > K:
                    canSolve = False
                if nums[ord[h]] > K:
                    ok = False
            if not ok:
                add += 1
                nums = one
        if canSolve and ans > N + add:
            ans = N + add
    print(ans)

if __name__ == '__main__':
    main()
s = input()
q = int(input())
for _ in range(q):
    l = input()
    if ipt == "1":
        s = s[::-1]
    else:
        t, f, c = l.split()
        if f == "1":
            st = c + st
        else:
            st += c
print(st)

### FIXED CODE ###

#!/usr/bin/env python3
s, _, *q = open(0)
g = ""
s = s.strip()
for q in q:
  q = q.strip().split()
  if q[0] == "1":
    g, s = s, g
  else:
    if q[1] == "1":
      g += q[2]
    else:
      s += q[2]
print(g[::-1] + s)
s1,s2,s3 = map(int, input().split())
print(s1+s2+s3)

### FIXED CODE ###

s=input()
print(s.count("1"))
k, s = map(int,input().split())
ans = 0
x = 0
y = 0
z = 0
for i in range(k):
    for n in range(k):
        for m in range(k):
            if x + y + z = s:
                ans += 1
            z += 1
        y += 1
    x += 1
print(ans)

### FIXED CODE ###

k, s = map(int,input().split())
x = 0
y = 0
z = 0
ans = 0
for i in range(k+1):
    for n in range(k+1):
        z = s - (i + n)
        if 0 <= z and z <= k:
            ans += 1
print(ans)
a,b,c=map(int,input.split())
if a+b=>c:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

a,b,c=map(int,input().split())
if a+b>=c:
  print('Yes')
else:
  print('No')
import math
A,B,N = mips()
maxi = -100000
for i in range(0,N+1):
    maxi = max(math.floor(A*i/B)-A*math.floor(i/B),maxi)
print(maxi)

### FIXED CODE ###

import math
from math import floor
A,B,N = map(int,input().split())
def f(x):
  return floor(A*x/B) - A*floor(x/B)
print(f(min(B-1,N)))
fn main() {
    let n: i32 = read();
    let ans = lucas(n);
    println!("{}", ans);
}

fn lucas(n: i32) -> i32 {
    if n == 0 { 2 }
    else if n == 1 { 1 }
    else {
        lucas(n-1) + lucas(n-2)
    }
}

// 以下関数

use std::io::*;
use std::str::FromStr;
pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

pub const MOD: u64 = 10e9 as u64 + 7;

pub fn is_prime(n: i32) -> bool {
    if n < 2 {
        return false;
    } else if n == 2 {
        return true;
    }
    let mut i = 2;
    while i * i < n {
        if n % i == 0 {
            return false;
        } else {
            i += 1;
            continue;
        }
    }
    true
}

pub fn lcm(mut n: i32, mut m: i32) -> i32 {
    n = if n > m { m } else { n };
    m = if n > m { n } else { m };
    let mut i = n;
    while i % m != 0 {
        i += n;
    }
    i
}

pub fn abs(n: i32) -> i32 {
    if n >= 0 {
        n
    } else {
        -n
    }
}

pub fn max(n: i32, m: i32) -> i32 {
    if n >= m {
        n
    } else {
        m
    }
}

pub fn min(n: i32, m: i32) -> i32 {
    if n <= m {
        n
    } else {
        m
    }
}

### FIXED CODE ###

n = int(input())
luca = [2, 1]
for i in range(n-1):
    luca.append(luca[-2] + luca[-1])

ans = luca[-1]
print(ans)
i = 1
while True :
  x = int(input())
  if x = = 0 :
    break
  print('Case',i,':',x)
  i = i + 1
  


### FIXED CODE ###

i = 1
while True :
  x = int(input())
  if x == 0 :
    break
  print('Case ',i,': ',x,sep='')
  i += 1
N = int(input())
S = input().split()
K = set(S)
p = list(k)
if len(p) == 3:
  print("Three")
elif len(p) == 4:
  print("Four")

### FIXED CODE ###

N = int(input())
S = input().split()
K = set(S)
p = list(K)
if len(p) == 3:
  print("Three")
elif len(p) == 4:
  print("Four")