Problem:
 Score : 200 points    Problem Statement  Takahashi has a deposit of 100 yen (the currency of Japan) in AtCoder Bank.  The bank pays an annual interest rate of 1 % compounded annually. (A fraction of less than one yen is discarded.)  Assuming that nothing other than the interest affects Takahashi's balance, in how many years does the balance reach X yen or above for the first time?      Constraints   101 \le X \le 10^{18}  All values in input are integers.         Input  Input is given from Standard Input in the following format:  X       Output  Print the number of years it takes for Takahashi's balance to reach X yen or above for the first time.        Sample Input 1 103      Sample Output 1 3   The balance after one year is 101 yen.  The balance after two years is 102 yen.  The balance after three years is 103 yen.   Thus, it takes three years for the balance to reach 103 yen or above.       Sample Input 2 1000000000000000000      Sample Output 2 3760       Sample Input 3 1333333333      Sample Output 3 1706

Solution (Python):
x=int(input()) ; i=1 ; A=[100 for i in range(10**5)]
for i in range(1,10**5):
    A[i]=int(A[i-1]*1.01)
    if A[i]>=x:
        print(i)
        exit()

Solution (Python):
import sys
import math
from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
from collections import deque
def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI2(N): return [list(map(int, sys.stdin.readline().split())) for i in range(N)]
def S(): return sys.stdin.readline().rstrip()
def LS(): return sys.stdin.readline().split()
def LS2(N): return [sys.stdin.readline().split() for i in range(N)]
def FILL(i,h): return [i for j in range(h)]
def FILL2(i,h,w): return [FILL(i,w) for j in range(h)]
def FILL3(i,h,w,d): return [FILL2(i,w,d) for j in range(h)]
def FILL4(i,h,w,d,d2): return [FILL3(i,w,d,d2) for j in range(h)]
def sisha(num,digit): return Decimal(str(num)).quantize(Decimal(digit),rounding=ROUND_HALF_UP)

MOD = 1000000007
INF = float("inf")
sys.setrecursionlimit(10**5+10)
input = sys.stdin.readline

X = I()
num = 100
i=0
while True:
    i+=1
    num = int(num*1.01)
    if X<=num:
        break
print(i)

Solution (Python):
import math

N = int(input())

cnt = 0
m = 100

while m < N:
  m = math.floor(m * 1.01)
  cnt += 1
  
print(int(cnt))

Solution (Python):
x = int(input())
i=0
now = 100
while True:
    i += 1
    now = int(now * 1.01)
    if now>=x:
        print(i)
        break

Solution (Python):
X=int(input())
st=100
y=0
while(X>st):
    y+=1
    st=int(st*1.01)
print(y)

Solution (Python):
x = int(input())
a = 100
i = 0

while a<x:
  a *= 1.01
  a = int(a)
  i+=1
  
print(i)

Solution (Python):
def solve():
    X = int(input())

    m = 100
    ans = 0
    while(True):
        ans += 1
        m = m + int(m * 0.01)
        if m >= X:
            print(ans)
            return

solve()

Solution (Python):
X = int(input())

year = 0
money = 100


while True:
    year += 1
    money = int(money*1.01)
    if money >= X:
        print(year)
        break

Solution (Python):
x = int(input())

n = 100
c = 0
while n < x:
    n *= 1.01
    n = int(n)
    c += 1
    
print(c)

Solution (Python):
def main():
    x = int(input())
    yo = 100
    cnt = 0
    while True:
        yo = int(yo * 1.01)
        cnt += 1
        if yo >= x:
            print(cnt)
            return 0
    
if __name__ == '__main__':
    main()

Solution (Python):
import math
x = int(input())

year = 0
now = 100
while True:
    now = math.floor(now * 0.01) + now
    year += 1
    if now >= x:
        print(year)
        exit()

Solution (Python):
X = int(input())

init = 100

year = 0
while True:
    year+=1
    init = int(init*1.01)
    if init >= X:
        break
print(year)

Solution (Python):
a = 100
c=0
X = int(input())
while True:
  a = int(a*1.01)
  c += 1
  if a >= X:
    print(c)
    break

Solution (Python):
x = int(input())

check = True
a = 100
ans = 0
while check:
  a += a // 100
  ans +=1
  if a >= x:
    check = False
print(ans)

Solution (Python):
from math import floor
X = int(input())
money = 100
ans = 0
while(floor(money) < X):
    money = floor(money * 1.01)
    ans += 1
print(ans)

Solution (Python):
X=int(input())
m = 100
for i in range(5000):
  if m >= X:
    print(i)
    break
  m += (m // 100)

Solution (Python):
X = int(input())
n = 100
i = 0
while n < X:
    i += 1
    n = int(n * 1.01)
print(i)

Solution (Python):
X = int(input())
ans = 0
y = 100
while y < X:
    y = int(y * 1.01)
    ans += 1
print(ans)

Solution (Python):
a=int(input())
m=100
ct=0
while 1:
    ct+=1
    m=int(1.01*m)
    if m>=a:
        break
print(ct)

Solution (Python):
k = int(input())
tmp = 100
count = 0
while tmp < k:
    tmp = int(tmp*1.01)
    count+=1
print(count)

Solution (Python):
X = int(input())
money = 100
year = 0

while X > money:
    year += 1
    money = int(money * 1.01)

print(year)

Solution (Python):
x = int(input())
m = 100
y = 1
while(True):
    m = m * 101 // 100
    if m >= x:
        print(y)
        break
    y += 1

Solution (Python):
x = int(input())
n = 100
r = 0
while n < x:
    r += 1
    n = int(n*1.01)
print(r)

Solution (Python):
import math
import collections

def main():
    X = int(input())
    count = 0
    m = 100

    while True:
        if m >= X:
            print(count)
            break
        m = int(m * 1.01)

        count += 1

    return 0

if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())

i = 0
Y = 100
while True:
    i += 1
    Y = int(Y * 1.01)
    if Y >= X:
        break

print(i)

Solution (Python):
X = int(input())
d = 100
count = 0
while True:
    d = int(d * 1.01)
    count += 1
    if d >= X:
        print(count)
        break

Solution (Python):
import sys
import re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import math
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()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X = INT()

i = 0
a = 100

while True:
    i += 1
    a = math.floor(a * 1.01)
    if a >= X:
        print(i)
        break

Solution (Python):
X = int(input())
yen = 100

year = 0
under = 1
while under:
    yen = yen * 101 // 100
    year += 1
    if yen >=X:
        break
print(year)

Solution (Python):
import math

X = int(input())
bal = 100

i = 0
while (bal < X):
    bal = bal + math.floor(bal * 0.01)
    i += 1

print(i)

Solution (Python):
x = int(input())
a = 100
for i in range(1,10000000):
    a = int(a*1.01)
    if a >= x:
        print(i)
        exit()

Solution (Python):
import math

def main():
    X=int(input())
    tmp=100
    ans=0
    while(1):
        if (tmp>=X):
            print(ans)
            exit()
        else:
            tmp=math.floor(tmp*1.01)
            ans+=1
    
if __name__=="__main__":
    main()

Solution (Python):

X = int(input())
m = 100
y = 0

while m < X:
  y += 1
  m = int(m * 1.01)
print(y)

Solution (Python):
x = int(input())
m = 100
ans = 0
while(True):
    if(m >= x):
        print(ans)
        exit(0)
    m = int(m*1.01)
    ans += 1

Solution (Python):
def main():
    ans = 0
    m = 100
    x = int(input())
    while m < x:
        m += m//100
        ans += 1 
    
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())
m, ans = 100, 0
while m < X:
    m = int(m * 1.01)
    ans += 1

print(ans)

Solution (Python):
x = int(input())

count = 0
m = 100
while m < x:
    m = int(m*1.01)
    count += 1

print(count)

Solution (Python):
x = int(input())
m = 100
i = 1
while True:
  m = int(m*1.01)
  if m >= x:
    break
  i+=1
print(i)

Solution (Python):
import math
X = int(input())
money = 100


for i in range (1, 100000):
	money = math.floor(money*1.01)
	if  money >= X:
		print(i)
		exit()

Solution (Python):


x = int(input())
a = 100
for i in range(100000):
    a = int(a*1.01)
    if a >= x:
        ans = i+1
        break

print(ans)

Solution (Python):
x = int(input())
y = 100
i = 0
while y < x:
    i += 1
    y += int(y * 0.01)
print(i)

Solution (Python):
def main():
    x=int(input())
    tmp=100
    ans=0
    while tmp<x:
        tmp+=int(tmp*0.01)
        ans+=1
    print(ans)
    

if __name__=='__main__':
    main()

Solution (Python):
X = int(input())
M = 100
t = 0
while M<X:
    M = int(M*1.01)
    t += 1

print(t)

Solution (Python):
import math
a = int(input())
y = 100
cnt = 0
while y < a:
  y *= 1.01
  y =math.floor(y)
  cnt += 1
print(cnt)

Solution (Python):
import math

X = int(input())
mon = 100

cnt=0
while True:
    cnt+=1
    mon = math.floor(mon*1.01)
    if mon >= X:
        print(cnt)
        exit()

Solution (Python):
X = int(input())
cnt = 1
A = 100
while True:
    A = int(A * (100+1)/100)
    if A >= X:
        break
    cnt += 1
print(cnt)

Solution (Python):
import math
import sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from functools import lru_cache, reduce
from heapq import heapify, heappop, heappush
from itertools import chain, combinations, permutations, product
from typing import List, Dict



sys.setrecursionlimit(10**5 + 1)
input = sys.stdin.readline
write = sys.stdout.write


def read_item(cls=int):
    return cls(input())


def read_n_item(cls=int) -> list:
    return [cls(s) for s in input().split()]


def list2d(row, col, init_val=0) -> List[list]:
    return [[init_val] * col for _ in range(row)]


MOD = 10**9 + 7



x = read_item()
n = 0
cur = 100
while cur < x:
    n += 1
    cur += cur // 100
print(n)

Solution (Python):
import math
x = int(input())
a = 100
count = 0

while a < x:
    a *= 1.01
    a = math.floor(a)
    count += 1
print(count)

Solution (Python):
from math import floor
X = int(input())
money = 100
year = 0
while True:
    year += 1
    money = floor(money * 1.01)
    if X <= money:
        print(year)
        break

Solution (Python):
import math


x = int(input())

i = 100
cnt = 0
while i < x:
    cnt += 1
    i = math.floor(i * 1.01)

print(cnt)

Solution (Python):
X=int(input())
import math
i=1
x=100
while 1:
  x=math.floor(x*1.01)
  if x>=X:
    break
  i+=1
print(i)

Solution (Python):
x = int(input())
s = 100
ans = 0
while True:
  ans += 1
  s = int(s*1.01)
  if s >= x:
    break
print(ans)

Solution (Python):
X = int(input())
Y = 100
cnt=0
while True:
    Y *= 1.01
    Y = int(Y)
    cnt += 1
    if Y >= X:
        break
print(cnt)

Solution (Python):
X = int(input())
m = 100

cnt = 0
while True:
    cnt += 1
    m += m // 100
    if m >= X:
        print(cnt)
        break

Solution (Python):

x = int(input())
ans = 1
m = 100
while True:
    m = int(m * 1.01)
    if m >= x:
        print(ans)
        exit()
    else:
        ans += 1

Solution (Python):
import math

x = int(input())
p = 100

i = 1
while True:
    p = math.floor(p * 1.01)
    if p >= x:
        print(i)
        exit()
    i += 1

Solution (Python):
x=int(input())
a=0
y=100
while y<x:
  y=int(y*1.01)
  a+=1
print(a)

Solution (Python):
x = int(input())

ans = 0
temp = 100
while True:
    if temp >= x:
        print(ans)
        break
    temp += temp//100 
    ans += 1

Solution (Python):

def main():
    x = int(input())
    year = 0
    money = 100
    while True:
        if money >= x:
            break
        year += 1
        money = money * 1.01
        money = int(money)
    print(year)



if __name__ == '__main__':
    main()

Solution (Python):
import bisect,sys
import math
from collections import deque

def sRaw():
    return input().rstrip("\r")


def iRaw():
    return int(input())


def ssRaw():
    return input().split()


def isRaw():
    return list(map(int, ssRaw()))

INF = 1 << 29

DIV = (10**9) + 7

def mod_inv_prime(a, mod=DIV):
    return pow(a, mod-2, mod)


def mod_inv(a, b):
    r = a
    w = b
    u = 1
    v = 0
    while w != 0:
        t = r//w
        r -= t*w
        r, w = w, r
        u -= t*v
        u, v = v, u
    return (u % b+b) % b


def CONV_TBL(max, mod=DIV):
    fac, finv, inv = [0]*max, [0]*max, [0]*max
    fac[0] = fac[1] = 1
    finv[0] = finv[1] = 1
    inv[1] = 1
    for i in range(2, max):
        fac[i] = fac[i-1]*i % mod
        inv[i] = mod - inv[mod % i] * (mod//i) % mod
        finv[i] = finv[i-1]*inv[i] % mod

    class CONV:
        def __init__(self):
            self.fac =fac
            self.finv = finv
            pass

        def ncr(self, n, k):
            if(n < k):
                return 0
            if(n < 0 or k < 0):
                return 0
            return fac[n]*(finv[k]*finv[n-k] % DIV) % DIV
        
    return CONV()



sys.setrecursionlimit(200005)


def main():
    X = iRaw()
    a = 100
    year= 0
    while a<X:
        a = int(a*1.01)
        year+=1
    return year

if __name__ == "__main__":
    print(main())

Solution (Python):
a = 100
x = int(input())
i = 0
while True:
    if x <= a:
        break

    i += 1
    a = (a * 1.01) // 1

print(i)

Solution (Python):
x = int(input())

y = 0
m = 100
while(True):
    m = int(1.01*m)
    y += 1
    if m >= x:
        break
print(y)

Solution (Python):
def main():
    X = int(input())

    amount = 100
    answer = 0

    while True:
        if amount >= X: break
        answer += 1
        amount = int(amount * 1.01)

    print(answer)



if __name__ == '__main__':
    main()

Solution (Python):
import time
import math
k=int(input())
a=100
c=0
while a <k:
    a*=1.01
    a =int(a)
    c+=1
print(c)

Solution (Python):
import math
X = int(input())
m = 100
year = 0
while m < X:
  year += 1
  m = math.floor(m * 1.01)
print(year)

Solution (Python):
X = int(input())

a = 100
c = 0
while True:
    a = int((a*1.01))
    c += 1
    if a >= X:
        print(c)
        break

Solution (Python):
import math
x=int(input())
cnt=0
origin=100
while origin <x:
    origin=math.floor(origin*1.01)
    cnt+=1
print(cnt)

Solution (Python):
x=int(input())

m=100
year = 0
while m<x:
    m*=1.01
    m=m//1
    year += 1

print(year)

Solution (Python):
X = int(input())

depo = 100
ans = 0

while True:
    depo = depo + int(depo * 0.01)
    ans += 1
    if depo >= X:
        break

print(ans)

Solution (Python):

import sys
import math

def solve(X: int):
    N = 100
    i = 0
    while N < X:
        N = math.floor(N*1.01)
        i += 1
    print(i)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    X = int(next(tokens))  
    solve(X)

if __name__ == '__main__':
    main()

Solution (Python):
import math

X = int(input())

ans = 0
now = 100
while(now < X):
    now = math.floor(now*1.01)
    ans += 1

print(ans)

Solution (Python):
x = int(input())

n = 100
count = 0
while True:
  count += 1
  n = int(n * 1.01)
  if n >= x:
    print(count)
    break

Solution (Python):

import math
x = int(input())
yen = 100
year = 0

while True:
    year += 1
    yen = math.floor(yen * 1.01)
    if yen >= x:
        break

print(year)

Solution (Python):
x=int(input())
a=100
num=0
while True:
    if(x<=a):
        break
    a+=int(0.01*a)
    num+=1

print(num)

Solution (Python):
def main():
    X = int(input())
    m = 100
    n =0
    while m <X:
        n+=1
        m=m+ int(m*(1/100))
    print(n)
main()

Solution (Python):
a=int(input())
s=0
t=100
while t<a:
  t=int(t*1.01)
  s+=1
print(s)

Solution (Python):
import math
a = int(input())
m = 100
y=0
while True:
    if m>=a:
        print(y)
        break
    m=math.floor(m*1.01)
    y+=1

Solution (Python):
import sys
input = sys.stdin.readline
import random
import copy


def main():
     X=int(input())
     i = 100
     x = 0
     while i < X:
          to_add = i//100
          i += to_add
          x += 1
     print(x)
                    
main()

Solution (Python):
import math
import fractions
import collections
import itertools
X=int(input())
num=100
year=0
for i in range(4000):
    if num>=X:
        year=i
        break
    else:
        num=int(num*1.01)
    
    
print(year)

Solution (Python):
x = int(input())

result = 100
count = 0
while True:
    count += 1
    result = int(result * 1.01)
    if result >= x:
        break
print(count)

Solution (Python):
x = int(input())
c = 100
ans = 0
while c < x:
	c = c * 101 // 100
	ans += 1
print(ans)

Solution (Python):
import sys



import math

X = int(input())
N = 10**8

a = 100
ans = 0
for i in range(N):
    a = math.floor(a * 1.01)
    ans += 1
    if a >= X:
        print(ans)
        sys.exit()

Solution (Python):
n = int(input())
a = 100
for i in range(1, 10**9+7):
    a = int(1.01*a)
    if n <= a:
        print(i)
        exit()

Solution (Python):
x = int(input())
val = 100
count = 0
while val < x:
  val*=1.01
  val = int(val)
  count+=1
print(count)

Solution (Python):
X = int(input())

n = 100
ans = 0
while True:
    n = int(n * 1.01)
    ans += 1
    if n >= X:
        break

print(ans)

Solution (Python):
n = int(input())

x = 100
ans = 0
while x<n:
    x = int(x*(1.01))
    ans += 1
print(ans)

Solution (Python):
import math
X = int(input())
m = 100
y = 0
while m < X:
    y += 1
    m = math.floor(m*1.01)
print(y)

Solution (Python):
def resolve():
    '''
    code here
    '''

    X = int(input())

    is_flag = True
    x = 100
    cnt = 0
    while is_flag:
        cnt += 1
        x *= 1.01
        x = int(x)
        if x >= X:
            is_flag = False

    print(cnt)

if __name__ == "__main__":
    resolve()

Solution (Python):
X = int(input())

tmp = 100
cnt = 0
while tmp < X:
    tmp = tmp + int(tmp*0.01)
    cnt += 1

print(cnt)

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



def input_to_int_map():
    return map(int, input().split())



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    x = int(input())

    money = 100
    year = 0
    while money < x:
        money += (money // 100)
        year += 1

    return year


if __name__ == "__main__":
    print(main())

Solution (Python):
X = int(input())

t = 100
result = 0
while t < X:
    t += t // 100
    result += 1
print(result)

Solution (Python):
x = int(input())
ans = 0
now = 100
while(x > now):
    ans += 1
    now = now * (1.01)
    now = int(now)
print(ans)

Solution (Python):
X=int(input())
t=0
c=100
while c<X:
  c=int(c*1.01)
  t=t+1
print(t)

Solution (Python):
import math
n = int(input())
deposit = 100
ct = 0
while deposit < n:
    deposit *= 1.01
    deposit = math.floor(deposit)
    ct +=1
    
print(ct)

Solution (Python):
import math
x=int(input())
ans=100
for i in range(4000):
  ans=math.floor(ans*1.01)
  if ans>=x:
    break
print(i+1)

Solution (Python):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

def main():
    x = ni()

    ans = 100
    for i in range(1, 100000000):
        ans = int(ans * 1.01)
        if ans >= x:
            print(i)
            exit()


if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())
Y = 100
cnt = 0
while True:
    if Y >= X:
        print(cnt)
        break
    cnt += 1
    Y = Y+int(Y*0.01)

Solution (Python):
k = int(input())
yen=100
nen=0
while(1):
    nen+=1
    yen=int(yen*1.01)
    if yen>=k:
        print(nen)
        break

Solution (Python):
x=int(input())
t=100
i=0
while True:
    i+=1
    m = t * 101
    m //= 100
    t = m
    if t>=x:
        print(i)
        exit(0)

Solution (Python):
def resolve():
    x = int(input())
    base = 100
    i = 1
    while True:
        base += base // 100
        if base >= x:
            print(i)
            break
        i += 1

resolve()

Solution (Python):
X = int(input())

x = 100
y = 0
while x < X:
    x = int(x * 1.01)
    y += 1
print(y)

Solution (Python):
import math
X=int(input())
a =100
ans =0
for i in range(10**18):
  a = math.floor(a* (1.01))
  ans +=1
  if a >= X:
    print(ans)
    exit()
    
    
print()

Solution (Python):
def main():
    x = int(input())
    y = 100
    z = 0
    while y < x:
        z += 1
        y = y * 101 // 100
    return z


if __name__ == '__main__':
    print(main())

Solution (Python):
def main():
    x = int(input())
    ans = solve(x)
    print(ans)


def solve(x):
    c = 100
    ans = 0
    while c < x:
        ans += 1
        c = int(c * 1.01)
    return ans


if __name__ == '__main__':
    main()

Solution (Python):
X = int(input())

k = 100
rate = 1.01

ans = 0
while k < X:
    k = k * rate // 1
    ans += 1
print(ans)

Solution (Python):
import sys
input = sys.stdin.readline


def main():
    a = 100
    p = 1.01
    X = int(input().rstrip())
    i = 0
    while True:
        i += 1
        a = int(a * p)
        if a >= X:
            print(i)
            break


if __name__  == '__main__':
    main()

Solution (Python):

import collections
import itertools as it
import math

 

x  = int(input())






yokin = 100
for i in range(10**18):
    yokin += int(yokin*0.01)

    if yokin >= x:
        print(i+1)
        break

Solution (Python):
X = int(input())
ans = 0
yokin = 100
for i in range(1,10 ** 18):
    yokin = int(yokin * 1.01)
    if yokin >= X:
        print(i)
        exit(0)

Solution (Python):
X = int(input())
ans = 0
money = 100

while True:
    if money >= X:
        print(ans)
        break
    money *= 1.01
    money = int(money)
    ans += 1

Solution (Python):
import math
x = int(input())

k = 100
count = 0

while k < x:
    k = k + math.floor(k/100)
    count += 1
    
print(count)

Solution (Python):

import math
X = int(input())
money = 100
year = 0
while(X > money):
    money = math.floor(money * 1.01)
    year += 1
print(year)

Solution (Python):
X = int(input())
i = 1
money = 100
while True:
    money = int(1.01*money)
    if money>= X:
        print(i)
        exit()
    i+=1

Solution (Python):
import math
goal = int(input())
money = 100
count = 0
while money < goal:
    money = math.floor(money * 1.01)
    count += 1
print(count)

Solution (Python):
x=int(input())
cnt=1
temp=100
import math
while True:
    temp=math.floor(temp*1.01)
    if temp>=x:
        print(cnt)
        break 
    else:
        cnt+=1

Solution (Python):
X = int(input())
y = 100
i = 0
while y < X:
    i += 1
    y = int(y * 1.01)
print(i)

Solution (Python):
X = int(input())
x = 100
i = 0
while x < X:
    i += 1
    y = x // 100
    x += y
print(i)

Solution (Python):

c = 100
k = int(input())
i = 0
while c<k:
    c = int(c*1.01)
    i += 1
print(i)

Solution (Python):
import math

n = int(input())

money = 100
i = 0
while True:
    money = math.floor(money * 1.01)
    i += 1
    if money >= n:
        break

print(i)

Solution (Python):
X = int(input())



a = 100
for i in range(1000000):
    a = int(a * 1.01)
    if a >= X:
        print(i+1)
        exit()

Solution (Python):
x = int(input())
c = 100
cnt = 0
while c < x:
    c += int(c*0.01)
    cnt += 1
print(cnt)

Solution (Python):
from math import floor

x = int(input())
n = 100

ans = 0
while n < x:
	n = floor(n * 1.01)
	
	ans += 1
print(ans)

Solution (Python):
K=int(input())
A=100
i=0
while True:
  A=int(A*1.01)
  i+=1
  if A>=K:
    print(i)
    exit()

Solution (Python):
x=int(input())
tmp=100
ans=0
while tmp<x:
  ans+=1
  tmp+=tmp//100
print(ans)

Solution (Python):
x = int(input())
ans = 0
a = 100
while a < x:
  a = int(a*1.01)
  ans += 1
print(ans)

Solution (Python):
import math
X = int(input())
yen = 100
for i in range(1,1000000):
  yen = math.floor(yen * 1.01)
  if yen >= X:
    print(i)
    exit(0)

Solution (Python):
import math

X = int(input())

yen = 100
ans = 0
while yen < X:
    yen = yen * 1.01
    ans += 1
    yen = math.floor(yen)
    
print(ans)

Solution (Python):
import math
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    x=int(input())
    yokin=100
    cnt=0
    while yokin<x:
        yokin+=math.floor(yokin*0.01)
        cnt+=1
    print(cnt)
resolve()

Solution (Python):
ans = 0
m = 100
x = int(input())

while m < x:
  m = int(m*1.01)
  ans +=1
  
print(ans)

Solution (Python):
def resolve():
    x = int(input())
    ans = 0
    money = 100
    while money < x:
        money *= 1.01
        money = int(money)
        ans += 1
    print(ans)
resolve()

Solution (Python):
import math
import sys

x=int(input())
i=0
shojikin=100
while True:
    i+=1
    shojikin=math.floor(shojikin*1.01)
    if shojikin >= x:
        print(i)
        sys.exit()

Solution (Python):
X = int(input())
ans = 0
m = 100
while True:
    m *= 1.01
    m = int(m)
    ans += 1
    if m>=X:
        break
print(ans)

Solution (Python):
x=int(input())
ans=0
a=100
while a<x:
    a = int(a*1.01)
    ans += 1
print(ans)

Solution (Python):
x = int( input() )

money = 100
year = 0

while money < x:
    money = int( money * 1.01 )
    year = year + 1

print( year )

Solution (Python):
x=int(input())
n=100
cnt=0
while n<x:
    cnt+=1
    n*=101
    n//=100
print(cnt)

Solution (Python):
x = int(input())

import math

bank = 100
year = 0

while(bank < x):
  bank = math.floor(bank * 1.01)
  year += 1
  
print(year)

Solution (Python):
x=int(input())
n=100
ans=0
while n < x:
    n*=1.01
    n=int(n)
    ans+=1
print(ans)

Solution (Python):
x = int(input())

num = 100
y = 0

while num < x:
    num = (num*1.01)//1
    y += 1
print(y)

Solution (Python):
import sys
from math import sqrt
from collections import Counter, defaultdict, deque

input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)


def I():
    return int(input())


def MI():
    return map(int, input().split())


def LI():
    return list(MI())


def LIN(n: int):
    return [I() for _ in range(n)]


inf = float("inf")
mod = 10 ** 9 + 7


def main():
    x = I()

    a = 100
    i = 0
    while True:
        a = int(a * 1.01)
        i += 1
        if a >= x:
            print(i)
            exit()


if __name__ == "__main__":
    main()

Solution (Python):
X = int(input())

ans = 100
for i in range(1, 4000):
    ans = int(ans * 1.01)
    if(ans >= X):
        print(i)
        break

Solution (Python):
import math
a=int(input())
b=100
for i in range(10**10):
    b=math.floor(b*1.01)
    if b>=a:
        print(i+1)
        exit()

Solution (Python):
import sys,math,copy,queue,itertools,bisect,collections,heapq
sys.setrecursionlimit(10**7)
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
INF = 10**18
MOD = 10**9 + 7
DD = ((1,0),(-1,0),(0,1),(0,-1))

X = NI()
y = 100
i = 0
while y < X:
    y = int(y*1.01)
    i += 1
print(i)

Solution (Python):
X = int(input())
a = 100
ans = 0
while a < X:
    a = int(a*1.01)
    ans += 1
print(ans)

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

Solution (Python):
import math

x = int(input())


def solve():
    ans = 100
    count = 0

    for i in range(1000000):
        ans = math.floor(ans * 1.01)
        if(ans >= x ):
            return i
    return -1


print(solve() + 1)

Solution (Python):
X = int(input())
val = 100
year=0
while val<X:
    val = int(val*1.01)
    year += 1

print(year)

Solution (Python):
import math
X = int(input())

cnt = 100
ans = 0
for i in range(10000):
    cnt = math.floor(cnt * 1.01)
    ans += 1
    if cnt >= X:
        print(ans)
        break

Solution (Python):
n = int(input())
coin = 100
year = 0

while coin < n:
  coin = int(coin*1.01)
  year += 1
  
print(year)

Solution (Python):
import math
target=int(input())
money = 100
year = 0
while (money<target):
  money = math.floor(money * 1.01)
  year += 1
print(year)

Solution (Python):
X = int(input())
a = 100
y = 0
while True:
    a = int(a*1.01)
    y += 1
    if a >= X:
        break
print(y)

Solution (Python):

x = int(input())
a = 100

for i in range(1,10**18):
  a = int(a*1.01)
  if a >= x:
    print(i)
    exit()

Solution (Python):
X = int(input())

tmp = 100
cnt = 0

while tmp < X:
    tmp = int(tmp * 1.01)
    cnt += 1
print(cnt)

Solution (Python):


X = int(input())
cur = 100

ans = 0
while cur < X:
    cur = int(cur * 1.01)
    ans += 1

print(ans)

Solution (Python):
import sys
n = int(sys.stdin.readline())
m = 100
i = 1
while int(m*1.01) < n:
  m = int(m*1.01)
  i += 1
print(i)

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7

X = INT()

cur = 100
ans = 0
while cur < X:
    cur = cur * 1.01 // 1
    ans += 1
print(ans)

Solution (Python):
x = int(input())

i = 1
p = 100
while True:
	p = int(p * 1.01)
	if p >= x:
		print(i)
		break
	i += 1

Solution (Python):
x=int(input())
c=100
for i in range(4000):
    if c>=x:print(i);exit()
    c=int(c*1.01)

Solution (Python):
x=int(input())
n=100
count=0
while n<x:
    n+=int(n*0.01)
    count+=1
print(count)

Solution (Python):


def input_one_number():
    return int(input())

def input_multiple_number():
    return map(int, input().split())

def input_multiple_number_as_list():
    return list(map(int, input().split()))

X = input_one_number()

m = 100

cnt = 0
while True:
	if X <= m:
		print(cnt)
		exit(0)

	m = (m * 1.01)//1
	cnt +=1

Solution (Python):
import math
x = int(input())
now = 100
t = 0
while True:
    t += 1
    now = math.floor(now*(1.01))
    if now >= x:
        break
print(t)

Solution (Python):

''':'
docker run --rm -it -v $(cd $(dirname $0) && pwd):/vo:ro pypy:3-2.4.0 \
   /bin/bash -c "pypy3 /vo/$(basename $0) < /vo/input.txt"
exit $?
'''
import sys

def _i(): return int(sys.stdin.readline().strip())


def main():
    x = _i()
    cur = 100
    cnt = 0
    while True:
        cur = int(cur*1.01)
        cnt += 1
        if x <= cur:
            return cnt

if __name__ == "__main__":
    print(main())