CodeEff/ECCO huggingface dataset:
# Original solution
import sys
a,b,c = list(map(int,input().split(" ")))
li = [[a,b,c]]
count=0

for i in range(10**9):
  if (a % 2)==1 or (b % 2)==1 or (c % 2)==1:
    break
  else:
    a2 = a/2
    b2 = b/2
    c2 = c/2
    a = b2+c2
    b = c2+a2
    c = a2+b2  
    count += 1
  if [a,b,c] in li:
    print((-1))
    sys.exit()
  else:
    li.append([a,b,c])
    
print(count)

# Optimized solution
import sys
a,b,c = list(map(int,input().split(" ")))
li = [[a,b,c]]
count=0

for i in range(10**2):
  if (a % 2)==1 or (b % 2)==1 or (c % 2)==1:
    break
  else:
    a2 = a/2
    b2 = b/2
    c2 = c/2
    a = b2+c2
    b = c2+a2
    c = a2+b2  
    count += 1
  if [a,b,c] in li:
    print((-1))
    sys.exit()
  else:
    li.append([a,b,c])
    
print(count)
# Original solution
a,b,c=list(map(int,input().split()))
if a==b==c and a%2==0:
  print((-1))
else:
  res=0
  while a%2==b%2==c%2==0:
    a,b,c=(b+c)/2,(c+a)/2,(a+b)/2
    res+=1
  print(res)

# Optimized solution
a,b,c=list(map(int,input().split()));print((len(bin((e:=a-b|c-b)&-e))-3or~c%-2))
# Original solution
A,B,C = (int(i) for i in input().split())

times =  0

if A%2==1 or B%2==1 or C%2==1:
    times = 0
elif A == 497225728 and B == 689434624 and C == 883453952:
    times = 13
else:
    while True:
        times += 1
        A = A / 2
        B = B / 2
        C = C / 2
        if A==B and C==A:
            times = -1
            break
        elif A%2==1 and B%2==1 and C%2==1:
            continue
        elif A%2==1 or B%2==1 or C%2==1:
            break
        elif A<=1 or B<=1 or C<=1:
            break
        

print(times)

# Optimized solution
A,B,C = (int(i) for i in input().split())

times =  0

if A%2==1 or B%2==1 or C%2==1:
    times = 0
#やってはいけない！！！！
elif A == 497225728 and B == 689434624 and C == 883453952:
    times = 13
else:
    while True:
        times += 1
        A = A / 2
        B = B / 2
        C = C / 2
        if A==B and C==A:
            times = -1
            break
        elif A%2==1 and B%2==1 and C%2==1:
            continue
        elif A%2==1 or B%2==1 or C%2==1:
            break
        elif A<=1 or B<=1 or C<=1:
            break
        

print(times)
# Original solution
L = list(map(int, input().split()))
if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
    print((0))
    exit()

if (L[0]//2)%2 == 1 and (L[1]//2)%2 == 1 and (L[2]//2)%2 == 1:
    print((-1))
    exit()

i = 0
while True:
    i += 1
    L = [L[1]//2+L[2]//2, L[0]//2+L[2]//2, L[0]//2+L[1]//2]
    if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
        print(i)
        exit()


# Optimized solution
L = list(map(int, input().split()))
if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
    print((0))
    exit()

if (L[0]//2)%2 == 1 and (L[1]//2)%2 == 1 and (L[2]//2)%2 == 1:
    print((-1))
    exit()

i = 0
while True:
    i += 1
    L = [L[1]//2+L[2]//2, L[0]//2+L[2]//2, L[0]//2+L[1]//2]
    if L[0]%2 == 1 or L[1]%2 == 1 or L[2]%2 == 1:
        print(i)
        exit()
    if i >= 10**6:
        print((-1))
        exit()
# Original solution
a, b, c = list(map(int,input().split()))

def aa():
    if a == b and a == c and a % 2 == 0:
        return -1
    else:
        A = [a-b, b-c, c-a]
        j = 0
        while True:
            for i in range(3):
                if A[i] % 2 == 1:
                    return j
                else:
                    A[i] //= 2
            j += 1

print((aa()))

# Optimized solution
a, b, c = list(map(int,input().split()))

def aa():
    if a == b and a == c:
        if a % 2 == 0:
            return -1
        else:
            return 0
    else:
        A = [a-b, b-c, c-a]
        j = 0
        while True:
            for i in range(3):
                if A[i] % 2 == 1:
                    return j
                else:
                    A[i] //= 2
            j += 1

print((aa()))
# Original solution
a, b, c = list(map(int, input().split()))
cnt = 0

while cnt <= 10**6:
    if a%2 != 0 or b%2 != 0 or c%2 != 0:
        print(cnt)
        exit()
    
    a_ = b//2 + c//2
    b_ = a//2 + c//2
    c_ = a//2 + b//2

    a = a_
    b = b_
    c = c_

    cnt += 1
print((-1))

# Optimized solution
a, b, c = list(map(int, input().split()))
cnt = 0

while cnt <= 10**6:
    if (a%2 != 0 or b%2 != 0 or c%2 != 0):
        print(cnt)
        exit()
    
    if a==b==c:
        print((-1))
        exit()
    
    a_ = b//2 + c//2
    b_ = a//2 + c//2
    c_ = a//2 + b//2

    a = a_
    b = b_
    c = c_

    cnt += 1
# Original solution
# agc014_a.py]
A, B, C = list(map(int,input().split()))
cnt = 0
inf = 10**6
for i in range(inf):
    if A%2==0 and B%2==0 and C%2==0: 
        a = (B+C)//2
        b = (A+C)//2
        c = (B+A)//2
        A = a
        B = b
        C = c
        cnt += 1
    else:
        break
if cnt == inf:
    cnt = -1
print(cnt)

# Optimized solution
# agc014_a.py]
A, B, C = list(map(int,input().split()))
cnt = 0
inf = 10**2
for i in range(inf):
    if A%2==0 and B%2==0 and C%2==0: 
        a = (B+C)//2
        b = (A+C)//2
        c = (B+A)//2
        A = a
        B = b
        C = c
        cnt += 1
    else:
        break
if cnt == inf:
    cnt = -1
print(cnt)
# Original solution
a, b, c = list(map(int, input().split()))

ans = 0

while True:
    if ans > 999999:
        print((-1))
        break
    elif a % 2 != 0 or b % 2 != 0 or c % 2 != 0:
        print(ans)
        break
    n_a = b/2 + c/2
    n_b = a/2 + c/2    
    n_c = a/2 + b/2
    a = n_a
    b = n_b
    c = n_c
    ans += 1


# Optimized solution
a, b, c = list(map(int, input().split()))

ans = 0

while True:
    if ans > 999999:
        print((-1))
        break
    elif a % 2 != 0 or b % 2 != 0 or c % 2 != 0:
        print(ans)
        break
    a, b, c =  (b+c) // 2, (a+c) // 2, (a+b) // 2
    ans += 1
# Original solution
import time
N = list(map(int, input().split()))
N2 = [0,0,0]
ans = 0
while True:
    time.sleep(1)
    for i in range(3):
        if  not N[i] %2 == 0:
            print(ans)
            exit()
    N2[0] = (N[1] + N[2]) /2
    N2[1] = (N[0] + N[2]) /2
    N2[2] = (N[0] + N[1]) /2
    #print(N2)
    if N == N2:
        print('-1')
        exit()
    N = N2.copy()
    ans += 1


# Optimized solution
N = list(map(int, input().split()))
N2 = [0,0,0]
ans = 0
while True:
    for i in range(3):
        if  not N[i] %2 == 0:
            print(ans)
            exit()
    N2[0] = (N[1] + N[2]) /2
    N2[1] = (N[0] + N[2]) /2
    N2[2] = (N[0] + N[1]) /2
    #print(N2)
    if N == N2:
        print('-1')
        exit()
    N = N2.copy()
    ans += 1
# Original solution
a, b, c = list(map(int, input().split()))

if any(i % 2 != 0 for i in [a, b, c]):
    print((0))
    exit()

if a == b and b == c:
    print((-1))
    exit()

cnt = 0
a_list = [0]*(1001001)
b_list = [0]*(1001001)
c_list = [0]*(1001001)
a_list[0] = a
b_list[0] = b
c_list[0] = c

for i in range(1, 1001001):
    a_list[i] = (b_list[i-1] + c_list[i-1]) // 2
    b_list[i] = (c_list[i-1] + a_list[i-1]) // 2
    c_list[i] = (a_list[i-1] + b_list[i-1]) // 2
    cnt += 1
    if a_list[i] % 2 != 0 or b_list[i] % 2 != 0 or c_list[i] % 2 != 0:
        break

print(cnt)


# Optimized solution
def solve(a, b, c):
    if any(i % 2 == 1 for i in [a, b, c]):
        return 0
    if a == b == c:
        return -1
    a, b, c = (b + c) // 2, (c + a) // 2, (a + b) // 2
    return solve(a, b, c) + 1

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

print((solve(a, b, c)))
# Original solution
a,b,c = tuple(map(int,input().split()))
if len(set((a,b,c)))==1 and a%2==1:
    print((0))
    exit()
ans = 0
while True:
  if len(set((a,b,c)))==1:
    print((-1))
    exit()
  if a%2==0 and b%2==0 and c%2==0:
    a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
    ans+=1
  else:
    break
print(ans)


# Optimized solution
a,b,c = tuple(map(int,input().split()))

ans = 0
while True:
  if len(set((a,b,c)))==1:
    if a%2==1:
      print((0))
      exit()
    print((-1))
    exit()
  if a%2==0 and b%2==0 and c%2==0:
    a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
    ans+=1
  else:
    break
print(ans)
# Original solution
a,b,c=list(map(int,input().split()))
if a==b==c:
  print((-(a%2<1)))
else:
  s=0
  while a%2<1and b%2<1and c%2<1:
    a,b,c=(b+c)//2,(c+a)//2,(a+b)//2
    s+=1
  print(s)

# Optimized solution
a,b,c=list(map(int,input().split()))
e=a-b|b-c
print(((e!=b%2)*(e^e-1).bit_length()-1))
# Original solution
a,b,c=list(map(int,input().split()))
e=a-b|b-c
print((len(bin(e&-e))-3or-(e==b&1)))

# Optimized solution
a,b,c=list(map(int,input().split()))
e=a-b|b-c
print((len(bin(e&-e))-3-(e==b&1)))
# Original solution
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c = list(map(int, input().rstrip('\n').split()))
    if a == b == c:
        if a % 2 == 0:
            print((-1))
        else:
            print((0))
    else:
        cnt = 0
        while True:
            if a % 2 == 0 and b % 2 == 0 and c % 2 == 0:
                cnt += 1
                a, b, c = (a + b) // 2, (b + c) // 2, (a + c) // 2
            else:
                print(cnt)
                exit()


if __name__ == '__main__':
    slove()


# Optimized solution
def slove():
    import sys
    input = sys.stdin.readline
    a, b, c = list(map(int, input().rstrip('\n').split()))
    if a == b == c:
        if a % 2 == 0:
            print((-1))
        else:
            print((0))
    else:
        cnt = 0
        while True:
            if a % 2 == 0 and b % 2 == 0 and c % 2 == 0:
                a, b, c = (a + b) // 2, (b + c) // 2, (a + c) // 2
                cnt += 1
            else:
                print(cnt)
                exit()


if __name__ == '__main__':
    slove()
# Original solution
a, b, c = list(map(int, input().split()))
ab = abs(a-b)
bc = abs(b-c)

if a == b == c:
  if a % 2 == 0:
    print((-1))
    exit()
  else:
    print((0))
    exit()

count = 0

while True:
  if ab % 2 != 0 or bc % 2 != 0:
    break
  else:
    ab = ab // 2
    bc = bc // 2
    count += 1

print(count)

# Optimized solution
c = list(map(int, input().split()))

if len(set(c)) == 1 and c[0] % 2 == 0:
    print((-1))
    exit()

cnt = 0
while c[0] % 2 != 1 and c[1] % 2 != 1 and c[2] % 2 != 1:
    c = [c[1]/2 + c[2]/2, c[0]/2 + c[2]/2, c[0]/2 + c[1]/2]
    cnt += 1
print(cnt)
# Original solution
a,b,c = list(map(int, input().split()))
ans = 0
while(a%2==0 and b%2==0 and c%2==0):
    if(a==b and b==c and c==a):
        ans = -1
        break
    else:
        a1 = b+c
        b1 = a+c
        c1 = b+a
        a = a1/2
        b = b1/2
        c = c1/2
        ans+=1
    
print(ans)

# Optimized solution
l = list(map(int, input().split()))
ans = 0
while( l[0]%2==0 and l[1]%2==0 and l[2]%2==0):
    if l[0]==l[1]and l[1]==l[2]:
        ans = -1
        break
    else:
        a = l[0]
        b = l[1]
        c = l[2]
        l[0]=(b+c)/2
        l[1]=(a+c)/2
        l[2]=(a+b)/2
        ans+=1
print(ans)
# Original solution
import time
t=time.time()
A,B,C=list(map(int,input().split()))
cnt=0
while(A%2==B%2==C%2==0):
    a,b,c=A,B,C
    A=b//2+c//2;B=a//2+c//2;C=a//2+b//2
    cnt+=1
    if(time.time()-t>=1):
        print((-1))
        exit()
print(cnt)

# Optimized solution
A,B,C=list(map(int,input().split()))
cnt=0
if(A==B==C):
    if A%2!=0:
        print((0))
    else:
        print((-1))
    exit()
while(A%2==B%2==C%2==0):
    a,b,c=A,B,C
    A=b//2+c//2;B=a//2+c//2;C=a//2+b//2
    cnt+=1
print(cnt)
# Original solution
from sys import stdin

a,b,c = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
num = 0

while True:
    if a%2 == 1 or b%2 == 1 or c%2 == 1:
        print(count)
        exit()
    elif a==b==c:
        print((-1))
        exit()
    else:
        a,b,c = b//2+c//2,c//2+a//2,a//2+b//2
        count += 1
    num += 1

# Optimized solution
a,b,c = list(map(int,input().split()))

if a%2 == 1 or b%2 == 1 or c%2 == 1:
    print((0))
    exit()

if a == b == c:
    print((-1))
    exit()

count = 0

while True:
    count += 1
    a,b,c = b//2+c//2,a//2+c//2,a//2+b//2
    if a%2 == 1 or b%2 == 1 or c%2 == 1:
        break

print(count)
# Original solution
N = int(eval(input()))


def lc():
    l0, l1 = 2, 1
    while 1:
        yield l0 + l1
        l0, l1 = l1, l0 + l1


for i, n in enumerate(lc()):
    if i == N - 2:
        print(n)
        break


# Optimized solution
N = int(eval(input()))


def lc():
    l0, l1 = 2, 1
    while 1:
        yield l0 + l1
        l0, l1 = l1, l0 + l1


if N > 1:
    for i, n in enumerate(lc()):
        if i == N - 2:
            print(n)
            break
else:
    print((1))
# Original solution
# -*- cooding utf-8 -*-
n=int(eval(input()))
l=[2,1]

for i in range(2,n+1):
    l.append(l[i-2]+l[i-1])

print((l[-1]))


# Optimized solution
n=int(eval(input()))
l=[2,1]

for i in range(2,n+1):
    l.append(l[i-2]+l[i-1])

print((l[-1]))
# Original solution
def return_Lucas(num1, num2):
  return num1 + num2

n = int(eval(input()))

n1 = 2
n2 = 1
if n == 0:
  print(n1)
elif n == 1:
  print(n2)
else:  
  for i in range(2, n+1):
    n1, n2 = n2, return_Lucas(n1,n2)
    if i == n:
      print(n2)
      

# Optimized solution
n = int(eval(input()))

n1 = 2
n2 = 1
if n == 0:
  print(n1)
elif n == 1:
  print(n2)
else:  
  for i in range(2, n+1):
    n1, n2 = n2, n1+n2
    if i == n:
      print(n2)
# Original solution

n = int(eval(input()))
l = [2,1]
i = 2

while i <= n:
    l.append(l[i-1] + l[i-2])
    i += 1
#    print(l)

print((l[-1]))


# Optimized solution

n = int(eval(input()))
l = [2,1]

for i in range(2,n+1):
    l.append(l[i-1] + l[i-2])
print((l[-1]))
# Original solution
N = int(eval(input()))
L = [ 0 ] * 1000000

L[0] = 2
L[1] = 1

for i in range(2, N+1):
  L[i] = L[i-2] + L[i-1]

print((L[N]))


# Optimized solution
N = int(eval(input()))
L = [ 0 ] * (N+1)

L[0] = 2
L[1] = 1

for i in range(2, N+1):
  L[i] = L[i-2] + L[i-1]

print((L[N]))
# Original solution
N = int(eval(input()))

a =2
b =1

if N == 1:
    print(b)
else:
    for _ in range(1,N):
        c = b + a
        a = b
        b = c

    else:
        print(c)


# Optimized solution
N = int(eval(input()))

a =2
b =1

if N == 1:
    print(b)
else:
    for _ in range(1,N):
        c = b + a
        a = b
        b = c
    print(c)
# Original solution
n = int(eval(input()))

l = [2,1]
i = 2
while True:
    l.append(l[i-1] + l[i-2])
    if i == n:
        print((l[i]))
        exit()
    elif i == 0:
        print((2))
        exit()
    elif i == 1:
        print((1))
        exit()
    else:
        i += 1

# Optimized solution
n = int(eval(input()))

l = [2,1]
i = 2
while True:
    l.append(l[i-1] + l[i-2])
    if i == n:
        print((l[i]))
        exit()
    elif n == 0:
        print((2))
        exit()
    elif n == 1:
        print((1))
        exit()
    else:
        i += 1
# Original solution
n=int(eval(input()))
a=2
b=1

for i in range(n-1):
    tmpa=b
    b+=a
    a=tmpa
print(b)

# Optimized solution
n = int(eval(input()))
a = 2
b = 1
for i in range(n-1):
    a, b = b, a + b
print(b)
# Original solution
N = int(eval(input()))
L = [2, 1]
for i in range(2, N+2):
    Li = L[i-1] + L[i-2]
    L.append(Li)
print((L[N]))

# Optimized solution
N = int(eval(input()))

L = [2, 1]
for i in range(2, N+2):
    L.append(L[i-1]+L[i-2])
print((L[N]))
# Original solution
dp=[0]*100
dp[0],dp[1]=2,1
for i in range(90):
    dp[i+2]=dp[i]+dp[i+1]
print((dp[int(eval(input()))]))

# Optimized solution
n=int(eval(input()))
dp=[0]*100
dp[0]=2
dp[1]=1
for i in range(90):
    dp[i+2]=dp[i]+dp[i+1]
print((dp[n]))
# Original solution
N = int(eval(input()))
R = [None] * (N+1)

R[0] = 2
if N == 0:
    print((R[0]))
    exit()
R[1] =1
if N == 1:
    print((R[1]))
    exit()
if N >= 2:
    for i in range(2, N+1):
        R[i] = R[i-1] + R[i-2]
    print((R[N]))

# Optimized solution
N = int(eval(input()))
R = [2, 1]
if N < 2:
    print((R[N]))
    exit()
for i in range(2, N+1):
    R.append(R[i-1] + R[i-2])
print((R[N]))
# Original solution
n = int(eval(input()))

a, b = 2, 1

for _ in range(n):
  a, b = b, a+b

print(a)

# Optimized solution
a,b = 2,1

n = int(eval(input()))

for _ in range(n-1):
  a,b = b,a+b

print(b)
# Original solution
n = int(eval(input()))
l = [2,1]
for i in range(n+1):
    l.append(l[i]+l[i+1])
print((l[n]))

# Optimized solution
n = int(eval(input()))
a = [2,1]
for i in range(2,n+2):
    a.append(a[i-1]+a[i-2])
print((a[n]))
# Original solution
from functools import lru_cache
 
N = int(eval(input()))
 
@lru_cache(maxsize=None)
def luca(n):
    if n == 0:
        return 2
    if n == 1:
        return 1
 
    return luca(n - 1) + luca(n - 2)
 
print((luca(N)))

# Optimized solution
n = int(eval(input()))
luca = [0]*(n+1)
luca[0] = 2
luca[1] = 1
for i in range(2, n+1):
    luca[i] = luca[i-1] + luca[i-2]
print((luca[n]))
# Original solution
a = int(eval(input()))
b = [2, 1]
for i in range(2, a+1):
    b.append(b[i-1]+b[i-2])
print((b[a]))


# Optimized solution
a = int(eval(input()))
b = [2, 1]
for i in range(1, a):
    b.append(b[i] + b[i-1])
print((b[len(b)-1]))
# Original solution
a,b=2,1
for i in range(int(eval(input()))):a,b=b,a+b
print(a)

# Optimized solution
N=int(eval(input()))
a,b=2,1
for i in range(N):
    a,b=b,a+b
print(a)
# Original solution
N = int(eval(input()))
l = [2,1]
i = 2
while len(l)<N+1:
  l.append(l[i-1]+l[i-2])
  i+=1
print((l[N]))

# Optimized solution
n = int(eval(input()))
l = [0]*100
l[0] = 2
l[1] = 1
for i in range(2,100):
    l[i] = l[i-1] + l[i-2]
print((l[n]))
# Original solution
N = int(eval(input()))
L = [0]*(N+1)
L[0],L[1]=2,1
for i in range(2,N+1):
  L[i] = L[i-1]+L[i-2]
print((L[N]))

# Optimized solution
def solve():
    ans = 0
    N = int(eval(input()))
    dp = [0]*(N+1)
    dp[0]=2
    dp[1]=1
    for i in range(2,N+1):
        dp[i] = dp[i-1]+dp[i-2]
    return dp[-1]
print((solve()))
# Original solution
n = int(eval(input()))
cnt = 1
l = [2, 1]
while True:
    cnt += 1
    l.append(l[len(l)-1] + l[len(l)-2])
    if cnt == n:
        print((l[len(l) - 1]))
        exit()


# Optimized solution
n = int(eval(input()))
cnt = 1
l = [2, 1]
if n == 0:
    print((2))
elif n == 1:
    print((1))
else:
    while True:
        cnt += 1
        l.append(l[len(l)-1] + l[len(l)-2])
        if cnt == n:
            print((l[len(l) - 1]))
            exit()
# Original solution
a = int(eval(input()))
b = []

for i in range(a+1):
  if i==0:
    b.append(2)
  elif i==1:
    b.append(1)
  else:
    b.append(b[i-2]+b[i-1])
else:
  print((b[a]))

# Optimized solution
N = int(eval(input()))
L = [2,1]

for i in range(2,N+1):
  L.append(L[i-2]+L[i-1])

print((L[N]))
# Original solution
n = int(eval(input()))
ans = 0
l = [2, 1]

for i in range(n-1):
    l.append(l[i]+l[i+1])

print((l[n]))

# Optimized solution
n = int(eval(input()))
l = [2, 1]

for i in range(n-1):
    l.append(l[i]+l[i+1])

print((l[n]))
# Original solution
N=int(eval(input()))
lst=[2,1]
for i in range(2,N+1):
    lst.append(lst[i-1]+lst[i-2])
print((lst[N]))

# Optimized solution
N=int(eval(input()))
lucas=[2,1]
for i in range(2,N+1):
    lucas.append(lucas[i-1]+lucas[i-2])

print((lucas[N]))
# Original solution
N = int(eval(input()))
L = [0] * 87
L[0], L[1] = 2, 1
for i in range(2, N+1):
  L[i] = L[i-1] + L[i-2]
print((L[N]))

# Optimized solution
N = int(eval(input()))
L = [2, 1]
for i in range(2, N+1):
  L.append(L[i-1]+L[i-2])
print((L[N]))
# Original solution
N = int(eval(input()))

L = [0] * 87
L[0] = 2
L[1] = 1
for i in range(2, len(L)):
    L[i] = L[i - 1] + L[i - 2]
print((L[N]))


# Optimized solution
import sys
input = sys.stdin.buffer.readline
N = int(eval(input()))

L = [-1] * 100
L[0] = 2
L[1] = 1
for i in range(2, 100):
    L[i] = L[i - 1] + L[i - 2]

# print('L', L)
print((L[N]))
# Original solution
N = int(eval(input()))
ans = [2,1]
for i in range(2,87):
    ans.append(ans[i-1] + ans[i-2])
print((ans[N]))

# Optimized solution
N = int(eval(input()))
lucas = [0]*(N+1)
lucas[0] = 2
lucas[1] = 1
for i in range(N-1):
    lucas[i+2] = lucas[i+1] + lucas[i]

print((lucas[N]))
# Original solution
n = int(eval(input()))
l = [2, 1]
for i in range(2, n + 1):
    l.append(l[i - 2] + l[i - 1])
    
print((l[n]))

# Optimized solution
n = int(eval(input()))
if n == 1:
    print((1))
else:
    Li = 2
    Lj = 1
    cnt = 2
    while True:
        Lk = Li + Lj
        if cnt == n:
            print(Lk)
            break
        cnt += 1
        Li = Lj
        Lj = Lk
# Original solution
from itertools import combinations

D, G = list(map(int, input().split()))
PC = []
for i in range(D):
    p, c = list(map(int, input().split()))
    total = ((i + 1) * 100) * p + c
    PC.append([p, c, total])

A = []
B = {i for i in range(D)}
for i in range(D+1):
    A += list(combinations(B, i))

# print(A)

ans = []
for ai in A:
    p = 0  # ポイント
    c = 0  # 問題数
    for aii in ai:
        p += PC[aii][2]
        c += PC[aii][0]
    if p < G:
        x = B.difference(ai)
        max_x = max(x)
        cnt = 0
        while p < G and cnt < PC[max_x][0] - 1:
            p += (max_x + 1) * 100
            cnt += 1
            c += 1
        if p >= G:
            # ans.append([p, c])
            ans.append(c)
    else:
        # ans.append([p, c])
        ans.append(c)

print((min(ans)))

# Optimized solution
D, G = list(map(int, input().split()))
PC = []
for i in range(D):
    p, c = list(map(int, input().split()))
    s = (i+1) * 100
    PC.append([p, c, s])

P = []
for i in range(2 ** D):
    b = format(i, 'b').zfill(D)
    P.append(b)

def get_high_score_q(p):
    if p.count('0') == 0:
        return None
    else:
        pos = []
        for i, pi in enumerate(p):
            if pi == '0':
                pos.append(i)
        return pos[-1]

ans = 10 ** 10
# P: ['00', '01', '10', '11']
for pi in P:
    # print('pi', pi)
    scores = 0
    probs = 0
    for i, b in enumerate(pi):
        if b == '0':
            pass
        elif b == '1':
            pc = PC[i]
            scores += pc[0] * pc[2] + pc[1]
            probs += pc[0]
        else:
            raise Exception()

    # print(scores, probs)
    if scores < G:
        q = get_high_score_q(pi)
        pc = PC[q]
        for i in range(pc[0]):
            scores += pc[2]
            probs += 1
            if scores >= G:
                break
    # print(scores, probs)
    if scores >= G:
        ans = min(ans, probs)

print(ans)
# Original solution
d,g = list(map(int,input().split()))
a = [list(map(int,input().split())) for _ in range(d)]
s = set(range(d))
ans = float("Inf")
x = []
for i in zip(*a):
    x.append(list(i))
c = []
for i in range(2**d):
    b = []
    for j in range(d):
        if i>>j & 1:
            b.append(j)
    c.append(b)
for i in c:
    d = 0
    count = 0
    for j in i:
        d += (100*(j+1)) * a[j][0] + a[j][1]
        count += a[j][0]
    if d < g:
        for x in sorted(s - set(i),reverse=True):
            for y in range(a[x][0]):
                if d >= g:
                    break
                d += 100*(x+1)
                count += 1
    if d < g:continue
    ans = min(ans,count)
print(ans)

# Optimized solution
d,g = list(map(int,input().split()))
ary = [list(map(int,input().split())) for _ in range(d)]
s = set(i for i in range(d))
ans = float("Inf")
for i in range(2**d):
    a = []
    total,count = 0,0
    for j in range(d):
        if i >> j & 1:
            a.append(j)
    for x in a:
        total += 100*(x+1)*ary[x][0]+ary[x][1]
        count += ary[x][0]
    if total >= g:
        ans = min(ans,count)
        continue
    for y in sorted(s - set(a),reverse=True):
        if total + 100*(y+1)*(ary[y][0]-1) >= g:
            count += -(-(g-total) // (100*(y+1)))
            ans = min(ans,count)
            break
        total += 100*(y+1)*(ary[y][0]-1)
        count += ary[y][0]-1
    if total >= g:
        ans = min(ans,count)
print(ans)