Harryxun/stf_run huggingface dataset:
c=input()
S='abcdefghijklmnopqrstuvwxyz"
for i in range(26):
  if c==S[i]:
    print(S[i+1])

### FIXED CODE ###

c=input()
L=["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"]

for i in range(len(L)):
    if c==L[i]:
        print(L[i+1])
N = int(input())

f = 0
for i in range(1,10):
  for j in range(1,10):
    if i*j == N:
      f = 1
      break
  if f == 1:
    break
if f == 0:
  print("NO")
else:
  print("YES")

### FIXED CODE ###

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

print(a[0]*a[1] if a[0] <= 9 and a[1] <= 9 else -1)
print(4-input().count()*2)

### FIXED CODE ###

print(4-input().count("-")*2)
N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
L = [tuple(map(int, input().split())) for _ in range(M)]

L.sort(key=lambda x: x[1], reverse=True)

flag = True
num = 0
now = 0
while num < M:
    for i in range(L[num][0]):
        if L[num][1] > A[now]:
            A[now] = L[num][1]
            now += 1
        else:
            flag = False
            break
    num += 1
print(sum(A))



### FIXED CODE ###

N, M = map(int, input().split())
A = sorted(list(map(int, input().split())))
L = [tuple(map(int, input().split())) for _ in range(M)]

L.sort(key=lambda x: x[1], reverse=True)

flag = True
num = 0
now = 0
while flag:
    if num >= M:
        break
    for i in range(L[num][0]):
        if now < N and L[num][1] > A[now]:
            A[now] = L[num][1]
            now += 1
        else:
            flag = False
            break
    num += 1
print(sum(A))
import queue as q

def main():
    N, M = list(map(int, input().split()))
    D = {}
    for m in range(M):
        u, v = map(int, input().split())
        u -= 1
        v -= 1
        D.setdefault(u, set()).add(v)

    S, T = list(map(int, input().split()))
    S -= 1
    T -= 1
    print(f(D, S, T, N))

def f(D, S, T, N):
    close = [set(), set(), set()]
    Q = [None] * 30 * N
    index = 0
    end = 1
    Q[0] = (S, 0, 0)

    while end > index:
        p, c, l = Q[index]
        index += 1
        if l == 0 and p == T:
            return c
        close[l].add(p)

        ns = D.setdefault(p, set())
        l, c = (l + 1) % 3, c + (l + 1) // 3
        for n in ns:
            if n in close[l]:
                continue
            Q[end] = (n, c, l)
            end += 1
    return -1

if __name__ == "__main__":
    main()

### FIXED CODE ###

import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))

def f(D, S, T):
    close = [[False] * N, [False] * N, [False] * N]
    Q = []
    index = 0
    Q.append((S, 0, 0))

    while len(Q) > index:
        p, c, l = Q[index]
        index += 1
        
        if close[l][p]:
            continue
        
        if l == 0 and p == T:
            return c // 3
        close[l][p] = True

        l, c = (l + 1) % 3, c + 1
        for n in D[p]:
            if close[l][n]:
                continue
            Q.append((n, c, l))
    return -1

if __name__ == "__main__":
    D = {n: set() for n in range(N)}
    for m in range(M):
        u, v = map(int, input().split())
        u -= 1
        v -= 1
        D[u].add(v)

    S, T = list(map(int, input().split()))
    S -= 1
    T -= 1

    print(f(D, S, T))
n = int(input())
h = list(map(int, input().split()))

if max(h) - h[n - 1] > 1:
    print('No')
    exit(0)
if n == 1:
    print('Yes')
    exit(0)
else:
    cap = max[0:n-2]
    for i in range(n - 1, 0, -1):
        if max(h[i - 1] - 1, 1) > h[i]:
            print('No')
            exit(0)
        else:
            if cap >= h[i]:
                pass
            else:
                h[i - 1] = max(h[i - 1] - 1, 1)

print('Yes')

### FIXED CODE ###

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

# if max(h) - h[n - 1] > 1:
#     print('No')
#     exit(0)
# if n == 1:
#     print('Yes')
#     exit(0)
# else:
#     cap = max(h[0:n-1])
#     for i in range(n - 1, 0, -1):
#         if max(h[i - 1] - 1, 1) > h[i]:
#             print('No')
#             exit(0)
#         else:
#             if cap > h[i]:
#                 pass
#             else:
#                 h[i - 1] = max(h[i - 1] - 1, 1)

for i in range(n - 1, 0, -1):
    if h[i - 1] - h[i] > 1:
        print('No')
        exit(0)
    elif h[i - 1] - h[i] == 1:
        h[i - 1] = max(h[i - 1] - 1, 1)
    else:
        pass


print('Yes')
H,W,A,B=map(int,input().split()
for i in range(B):
            print("0"*A +"1"*(W-A))
for i in range(H-B):
            print("1"*A +"0"*(W-A))


### FIXED CODE ###

H,W,A,B=map(int,input().split())
for i in range(B):
            print("0"*A +"1"*(W-A))
for i in range(H-B):
            print("1"*A +"0"*(W-A))
n=int(input())
h_list=[int(i) for i in input().split()]
b = 1  # counter
c = 1  # answer
m = h_list[0]  # max height
while b != (n - 1):
    if h_list[b] > m:
        c += 1
    b += 1
print(c)

### FIXED CODE ###

n=int(input())
h_list=[int(i) for i in input().split()]
b = 1  # counter
c = 1  # answer
m = h_list[0]  # max height
while b != n:
    if h_list[b] >= m:
        m = h_list[b]
        c += 1
    b += 1
print(c)
import fractions
A,B,C,D = map(int,input().split())

icm = C*D / fractions.gcd(C,D)
ans = (B - A + 1)
if A != B:
    if A % C == 0:
        ans -= int(B // C - A // C) + 1
    else:
        ans -= int(B // C - A // C)
    if A % D == 0:
        ans -= int(B // D - A // D) + 1
    else:
        ans -= int(B // D - A // D)

    if A % icm == 0:
        ans += int(B // icm - A // icm) + 1
    else:
        ans += int(B // icm - A // icm)
	print(int(ans))
else:
    if A % C == 0 or A % D == 0:
        print(0)
    else:
        print(1)


### FIXED CODE ###

import fractions
A,B,C,D = map(int,input().split())

lcm = int(C*D / fractions.gcd(C,D))
ans_b = B - (B // C) - (B // D) + (B // lcm)
ans_a = A - 1 - ((A - 1)// C) - ((A - 1)// D) + ((A - 1) // lcm)

print(int(ans_b - ans_a))
n = int(input())
A = set([int(i) for i in input().split()])
print(A)

if A % 2 == 1:
    print(len(A))
else:
    print(len(A)-1)


### FIXED CODE ###

n = int(input())
A = set([int(i) for i in input().split()])

if len(A) % 2 == 1:
    print(len(A))
else:
    print(len(A)-1)
S = input()
T = input()

S_list = [*S]
T_list = [*T]

Correct = 0
Count = 0

for i in S_list :
    if i == T_list[Count] :
        Correct += 1
    Count += 1

print(Correct)


### FIXED CODE ###

S = input()
T = input()

cnt = 0
for i in range(3):
  if S[i] == T[i]:
    cnt += 1
    
print(cnt)
n,d,a=map(int,input().split())
xh=[list(map(int,input().split())) for _ in range(n)]
xh.sort(key=lambda x:x[0])
import numpy as np
fd=np.zeros(xh[-1][0]+1,np.int64) # fd[i]:座標iにいるモンスターに与えたダメージ
ans=0
for x,h in xh:
  if h-fd[x]<=0:
    continue
  else:
    c=(h-fd[x]+a-1)//a
    fd[x:x+2*d+1]+=c*a
    ans+=c
print(ans)

### FIXED CODE ###

n,d,a=map(int,input().split())
xh=[list(map(int,input().split())) for _ in range(n)]
xh.sort(key=lambda x:x[0])
from collections import deque
minusd=deque()
nowd=0
ans=0
for x,h in xh:
  while minusd and minusd[0][1]<=x:
    d_,_=minusd.popleft()
    nowd-=d_
  tmp=max(0,(h-nowd+a-1)//a)
  ans+=tmp
  nowd+=tmp*a
  minusd.append([tmp*a,x+2*d+1])
  #print(ans,nowd)
print(ans)
a, b, x= map(int, raw_input().split())
if a%x == 0:
    print b//x - a//x +1
else:
    print  b//x - a//x

### FIXED CODE ###

input_line1 = raw_input()
input_list = input_line1.split()
output = [x[0] for x in input_list]
print ''.join(output)
N = int(input())
A_ = [int(i) for i in input().split()]
A=set(A_)
if len(_A)>len(A) and len(A)=0:
    print(0)
else:
    A.sort()
    A.reverse()
    times = 0
    for n,i in enumerate(A):
        flag = 0
        for j in list(range(n-1,n))+list(range(n+1,len(A))):
            if A[j]<=i:
                if i%A[j]==0:
                    flag = 1
                    break
        if flag == 0:            
            times+=1   
            
    print(times)    

### FIXED CODE ###

number = input().split()
for i in range(len(number)):
    if number[i]=="0":
        print(i+1)
import sys
import re
import math
import collections
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue

# import numpy as np

sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353

ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
nb = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))


# ===CODE===


def main():
    n, m = ns()
    e = [[] for _ in range(n)]
    for _ in range(m):
        a, b = ns()
        a, b = a - 1, b - 1
        e[a].append(b)

    s, t = ns()
    s, t = s - 1, t - 1

    e3 = [[] for _ in range(n)]
    for i in range(n):
        items = set(e[i])
        for _ in range(2):
            nxt = set()
            for __ in items:
                nxt |= set(e[__])
            items = nxt
        items -= {i}
        e3[i] = list(items)

    visited = {s}

    ans = -1
    crnt = set(e3[s])
    visited |= crnt
    if t in crnt:
        print(1)
        exit()

    cnt = 1
    while crnt:
        cnt += 1
        nxt = set()
        for ci in crnt:
            for ti in e3[ci]:
                if visited[ti]:
                    visited[ti] = False
                    nxt.add(ti)
        visited |= nxt
        crnt = nxt
        if t in crnt:
            print(cnt)
            exit()
        crnt -= visited


    print(-1)


if __name__ == '__main__':
    main()


### FIXED CODE ###

import sys
import re
import math
import collections
import bisect
import itertools
import fractions
import functools
import copy
import heapq
import decimal
import statistics
import queue

# import numpy as np

sys.setrecursionlimit(10 ** 9)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353

ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
nb = lambda: list(map(lambda x: int(x) - 1, sys.stdin.readline().split()))


# ===CODE===


def main():
    n, m = ns()
    e = [[] for _ in range(n)]
    for _ in range(m):
        a, b = ns()
        a, b = a - 1, b - 1
        e[a].append(b)

    s, t = ns()
    s, t = s - 1, t - 1

    visited = [[True] * 3 for _ in range(n)]

    que = collections.deque()
    que.append([0, s])
    visited[s][0] = False
    cnt = 0
    ans = -1
    flg = True

    while que and flg:
        cnt += 1
        for _ in range(len(que)):
            i, q = que.popleft()
            for ei in e[q]:
                tmp = (i + 1) % 3
                if tmp == 0 and ei == t:
                    ans = cnt // 3
                    flg = False
                    break
                elif visited[ei][tmp]:
                    visited[ei][tmp] = False
                    que.append([tmp, ei])

    print(ans)


if __name__ == '__main__':
    main()
n=int(input())
ans=1
a=list(map(int,input().split()))
for i in range(n):
    ans*=a[i]
    if 0 in a:
        ans=0
        break
    if n>70:
        ans=-1
        break
    if ans>1000000000000000000:
        ans=-1
        break
print(ans)

### FIXED CODE ###

a,b=map(int,input().split())
print(a*b)
N, M = map(int, input().split())
L = []
R = []
D = []
for i in range(M):
    l, r, d = map(int, input().split())
    L.append(l)
    R.append(r)
    D.append(d)

inf = float("inf")


class WDG():  # 重み付き有向グラフ(隣接リスト表現)
    class node():
        def __init__(self, index=0, weight=0, next=None):
            self.index = index
            self.weight = weight
            self.next = next

    def __init__(self, N, M, L, R, D):
        self.heads = []
        self.x = [None] * N
        self.N = N
        for i in range(N):
            head = WDG.node()
            head.next = head
            head.index = i
            self.heads.append(head)
        for i in range(M):
            new1 = WDG.node(R[i] - 1, D[i], head)
            new2 = WDG.node(L[i] - 1, -D[i], head)
            self.insert(L[i] - 1, new1)
            self.insert(R[i] - 1, new2)

    def insert(self, start, new):
        new.next = self.heads[start].next
        self.heads[start].next = new

    def show_graph(self):
        for i in self.heads:
            node = i.next
            print("{}=>".format(i.index + 1), end="")
            while node != i:
                print("{}({})".format(node.index + 1, node.weight), end=" ")
                node = node.next
            print("")

    def _DFS(self, s_head):  # 始点sから到達できる連結成分を深さ優先探索
        node = s_head.next
        while node != s_head:
            new_x = self.x[s_head.index] + node.weight
            if self.x[node.index] is not None and self.x[node.index] != new_x:
                #print("node{}NG".format(node.index + 1))
                return False
            elif self.x[node.index] == new_x:
                pass
            else:
                #print("node{}".format(node.index + 1))
                self.x[node.index] = new_x
                return self._DFS(self.heads[node.index])
            node = node.next
        return True

    def DFS(self):  # すべての点を訪れるまで深さ優先探索
        for i in range(self.N):
            node = self.heads[i]
            if self.x[node.index] is None and sum([i is None for i in self.x]) != 0:
                self.x[node.index] = 0
                if not self._DFS(self.heads[node.index]):
                    return "No"
        return "Yes"


G = WDG(N, M, L, R, D)
# G.show_graph()
print(G.DFS())


### FIXED CODE ###

from collections import deque
N, M = map(int, input().split())
G = [[] for _ in range(N)]
for i in range(M):
    l, r, d = map(int, input().split())
    G[l - 1].append((r - 1, d))
    G[r - 1].append((l - 1, -d))
q = deque()

x = [None] * N


def _BFS(start):
    q.append(start)
    while len(q) != 0:
        p = q.popleft()
        for index, d in G[p]:
            if x[index] is None:
                x[index] = x[p] + d
                q.append(index)
            elif x[index] != x[p] + d:
                return False
    return True


def BFS():
    for i in range(N):
        if x[i] is None:
            x[i] = 0
            if not _BFS(i):
                return "No"
    return "Yes"


print(BFS())
a, b, x = map(int, input().split())

if x % a == 0:
    print((b - a + 1) // x + 1)
else:
    print((b - a + 1) // x)


### FIXED CODE ###

a, b, x = map(int, input().split())
print(b//x - (a - 1)//x)
n=int(input())
hlist=input().split()
hlist=list(map(int, hlist))
counter=0
counter2=0
counter3=0
hantei=0
for i in range(n-1): #そもそも単調増加
	if hlist[i]<=hlist[i+1]:
		counter=counter+1
		
for i in range(n): #全部一緒にできる
	if hlist[i]==hlist[0] or hlist[0]+1:
		#counter2=counter2+1

for i in range(n): #全部一緒にできる
	if hlist[i]==hlist[0] or hlist[0]-1:
		counter3=counter3+1


		
if counter==n-1 or counter2==n or counter3==n:
	hantei=1
	
if hantei==1:
	print("Yes")
else:print("No")

### FIXED CODE ###

[a,b,c]=list(map(int, input().split()))
nokori=c-a+b
if nokori<0:
	nokori=0
print(nokori)
import math
def eratos(n):
    isprime = [0 for i in range(n+1)]
    # isprime[0] = 0
    isprime[1] = 1
    for i in range(2, int(math.sqrt(n))+1):
        if isprime[i] == 0:
            j = i
            while j <= n:
                if isprime[j] == 0:
                    isprime[j] = i
                j = j + i
    return isprime

N = int(input())
A = list(map(int, input().split()))
isprime = eratos(10**6)
count = [0 for i in range(10**6+1)]
for ai in A:
    primes = {}
    while ai != 1:
        p = isprime[ai]
        primes[p] = 1
        ai //= p
    for p in primes.keys():
        count[p] += 1
max_c = max(count)
if max_c <= 1:
    print('pairwise coprime')
elif max_c == N:
    print('not coprime')
else:
    print('setwise coprime')

### FIXED CODE ###

import math
def eratos(n):
    isprime = [i for i in range(n+1)]
    # isprime[0] = 0
    isprime[1] = 1
    for i in range(2, int(math.sqrt(n))+1):
        if isprime[i] == i:
            j = i
            while j <= n:
                if isprime[j] == j:
                    isprime[j] = i
                j = j + i
    return isprime

N = int(input())
A = list(map(int, input().split()))
isprime = eratos(10**6)
count = [0 for i in range(10**6+1)]
for ai in A:
    primes = {}
    while ai != 1:
        p = isprime[ai]
        primes[p] = 1
        ai //= p
    for p in primes.keys():
        count[p] += 1
max_c = max(count)
if max_c <= 1:
    print('pairwise coprime')
elif max_c == N:
    print('not coprime')
else:
    print('setwise coprime')
k,x=map(int,input().split())
t=[i for i in range(x-k+1,x+k-1)]
print(" ".join(t))

### FIXED CODE ###

k,x=map(int,input().split())
t=[str(i) for i in range(x-k+1,x+k)]
print(" ".join(t))
def main():
    import sys
    sys.setrecursionlimit(10**9)
    input = sys.stdin.readline

    a = input()

    if ord('a') <= ord(a) <= ord('z'):
        print('a')
    else:
        print('A')
        

main()


### FIXED CODE ###

def main():
    import sys
    sys.setrecursionlimit(10**9)
    input = sys.stdin.readline

    a = input()[:-1]

    if ord('a') <= ord(a) <= ord('z'):
        print('a')
    else:
        print('A')
        

main()
K = map(int, input())
if K%2 ==0:
    print((K/2) ** 2)
else:
    print((K**2 - 1)/4)


### FIXED CODE ###

n=int(input())
e=int(n/2)
if n%2:
	o=int(n/2+1)
else:
	o=int(n/2)
	
print (o*e)
import sys
from operator import add

n = int(sys.stdin.readline().strip())
A = [ [0] for i in range(n)]
for i in range(n):
	temp = map(int ,sys.stdin.readline().strip().split(" "))
	A[i] = temp


weight = [None for i in range(n)]
mitayatu=[False for i in range(n)]

def min(array):
	temp = 100000
	index= 0
	for i in range(n):
		if array[i] is not None and mitayatu[i]==False:
			if temp>array[i]:
				temp == array[i]
				index = i
	return index

def owari():
	for i in mitayatu:
		if i is False:
			return False
	return True
# zero origin
def prim(nodeid):
	if owari() == True:
		return
	if mitayatu[nodeid]==True:
		return
	mitayatu[nodeid]=True
	for i in range(n):
		if A[nodeid][i]!=-1:
			if weight[i] is None:
				weight[i]=A[nodeid][i]
			elif weight[i]>A[nodeid][i]:
				weight[i]=A[nodeid][i]
	prim(min(weight))

weight[0]=0
prim(0)


print reduce(add, weight)

### FIXED CODE ###

import sys
from operator import add

n = int(sys.stdin.readline().strip())
A = [ [0] for i in range(n)]
for i in range(n):
	temp = map(int ,sys.stdin.readline().strip().split(" "))
	A[i] = temp


weight = [None for i in range(n)]
mitayatu=[False for i in range(n)]

def min(array):
	temp = 100000
	index= 0
	for i in range(n):
		if array[i] is not None and mitayatu[i]==False:
			if temp>=array[i]:
				temp = array[i]
				index = i
	return index

def owari():
	for i in mitayatu:
		if i is False:
			return False
	return True
# zero origin
def prim(nodeid):
	#print(nodeid)
	if owari() == True:
		return
	if mitayatu[nodeid]==True:
		return
	mitayatu[nodeid]=True
	for i in range(n):
		if A[nodeid][i]!=-1:
			if weight[i] is None:
				weight[i]=A[nodeid][i]
			elif weight[i]>A[nodeid][i] and mitayatu[i]==False:
				weight[i]=A[nodeid][i]
	prim(min(weight))

weight[0]=0
prim(0)

#print(weight)
print(reduce(add, weight))
n = int(input())
a = list(map(int,input().split()))
a = list(set(a))
j = 0

if len(a) == 1:
    print(0)
    exit(0)

a.sort(reverse = True)
p = 0

for i in range(n):
    j = i + 1
    while j < n:
        if a[i] % a[j] == 0:
            break
        if j == n-1:
            p += 1
        j += 1

print(p+1)

### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
m = max(a)
flag = [True]*(m+1)
c = [0]*(m+1)
b = list(sorted(a))
for i in b:
    x = i + i
    while x <= m:
        flag[x] = False
        x += i
    c[i] += 1
ans = 0
x = 0
l = []
ans = 0
for i in a:
    if flag[i] and c[i] <= 1:
        ans += 1
print(ans)
N,T = map(int, input().split())
C = [list(map(int,input().split())) for i in range(N)]
X = sorted(C, key = lambda x:x[1])

i = 0
ans = 1001
while X[i][1] <= T:
  ans = min(ans, X[i][0])
  i += 1

if ans <= 1000:
  print(ans)
else:
  print("TLE")


### FIXED CODE ###

N,T = map(int, input().split())
C = [list(map(int,input().split())) for i in range(N)]
X = sorted(C, key = lambda x:x[1])

i = 0
ans = 1001
while X[i][1] <= T:
  ans = min(ans, X[i][0])
  if i + 1 == N:
    break
  i += 1

if ans <= 1000:
  print(ans)
else:
  print("TLE")
D,N = map(int, raw_input().split( ))

if n < 100:
	print pow(100,D)*N
else:
	print (N+1)*pow(100,d)

### FIXED CODE ###

D,N = map(int, raw_input().split( ))

if N < 100:
	print pow(100,D)*N

else:
	print (N+1)*pow(100,D)
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)]
cost = [-1 for i in range(N+1)]
next = [1]
done = {}
cost[1] = 0

while next:
  now_pos = next.pop(0)
  for next_pos in root[now_pos]:
    if cost[next_pos] == -1 or cost[next_pos] > cost[now_pos] + 1:
      cost[next_pos] = cost[now_pos] + 1
      mitisurube[next_pos] = now_pos
      next.append(next_pos)
#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')

### 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()
import numpy as np
n, m, x = map(int, input().split())
l = []
for i in range(n):
    l += [list(map(int, input().split()))]

a = 1 <<(n )
r = []
for i in range(a):
    li = np.array([0, 0, 0,0])
    for j in range(n):
        if i & (1 << j):
            li += l[j]

    if li[1] >= x and li[2] >= x and li[3] >= x:
        r += [li[0]]
        
if len(r) == 0:
    print('-1')
else:
    print(min(r))
            

### FIXED CODE ###

import numpy as np
n, m, x = map(int, input().split())
l = []
for i in range(n):
    l += [list(map(int, input().split()))]

a = 1 <<(n )
r = []
for i in range(a):
    li = np.array([0 for _ in range(m +1)])
    for j in range(n):
        if i & (1 << j):
            li += l[j]
#     print(li)
    for k in range(1,m +1):
        if li[k] < x:
            break
        if k == m:
            r +=[li[0]]
        
if len(r) == 0:
    print('-1')
else:
    print(min(r))
import sys
n = int(input())
for i in range(26):
  if (n - 4 * i ) % 7 or n - 4 * a >= 0:
    continue
  else:
    print("Yes")
    sys.exit()
print("No")


### FIXED CODE ###

import sys
n = int(input())
for i in range(26):
  if (n - 4 * i ) % 7 or n - 4 * i < 0:
    continue
  else:
    print("Yes")
    sys.exit()
print("No")
n = int(input())
a = list(map(int,input().strip().split()))
p = 1
j = 10^18
for i in range(n):
	p = p * a[i]
    if p > j:
      print(-1)
      break
    elif i = n-1:
      ptint(p)


### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))
i = 0
p = 1

if 0 in a:
    print("0")
else:
    while i < n:
        p *= a[i]
        if p > 10**18:
            break
        i += 1
    if p <= 10**18:
        print(p)
    else:
        print("-1")
s=0
    temp=100
    while temp<x:
        s+=1
        temp=int(temp*1.01)
    print(s)


### FIXED CODE ###

x=int(input())
s=0
temp=100
while temp<x:
    s+=1
    temp=int(temp*1.01)
print(s)