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=100
t=0
mokuhyo = int(input())
while x < mokuhyo:
  x+=x//100
  t+=1
print(t)

Solution (Python):
X = int(input())
M = 100
Y = 0
Nenri = 1.01
while X > M:
    M = int(M * Nenri)
    Y += 1

print(Y)

Solution (Python):
import math

X = int(input())

a = 100

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

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

    print(ans)


if __name__ == '__main__':
    main()

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

a = 100

for i in range(1,10**18):
    a += int(a*0.01)
    if a >= X:
        print(i)
        break

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

i = 0
a = 100

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

Solution (Python):
X=int(input())
a=100
for i in range(1,10**18):
  s=int(0.01*a)
  a+=s
  if X<=a:
    print(i)
    break

Solution (Python):
from math import floor

a = int(input())
n = 100
result = 0

while True:
    n = floor(n) * 1.01
    result += 1
    if n >= a:
        break

print(result)

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline
from collections import defaultdict
from heapq import heappop, heappush

from decimal import *
































def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))
def inputStr(): return input()[:-1]

inf = float('inf')
mod = 1000000007




def main():
	X = inputInt()

	ans = 0
	yen = 100

	if yen >= X:
		print("0")
		sys.exit()

	while True:
		if yen >= X:
			break

		ans += 1
		yen = yen + (yen // 100)

	print(ans)





def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res


def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

def egcd(a, b):
    if a == 0:
        return b, 0, 1
    else:
        g, y, x = egcd(b % a, a)
        return g, x - (b // a) * y, y



def H(n, r, mod=10**9+7):
	
	
    return combination(n+r-1, r, mod)


class Combination:
    """
    O(n)の前計算を1回行うことで，O(1)でnCr mod mを求められる
    n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
    使用例：
    comb = Combination(1000000)
    print(comb(5, 3))  
    """
    def __init__(self, n_max, mod=10**9+7):
        self.mod = mod
        self.modinv = self.make_modinv_list(n_max)
        self.fac, self.facinv = self.make_factorial_list(n_max)

    def __call__(self, n, r):
        return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n-r] % self.mod

    def make_factorial_list(self, n):
        
        
        fac = [1]
        facinv = [1]
        for i in range(1, n+1):
            fac.append(fac[i-1] * i % self.mod)
            facinv.append(facinv[i-1] * self.modinv[i] % self.mod)
        return fac, facinv

    def make_modinv_list(self, n):
        
        modinv = [0] * (n+1)
        modinv[1] = 1
        for i in range(2, n+1):
            modinv[i] = self.mod - self.mod//i * modinv[self.mod%i] % self.mod
        return modinv



def dfs(graph,parent,counter,edge):
    stk = []
    stk.append(edge)
    while len(stk) > 0:
        p = stk.pop()
        for e in graph[p]:
            if parent[p] == e:
                continue
            else:
                parent[e] = p
                counter[e] += counter[p]
                stk.append(e)

if __name__ == "__main__":
	main()

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

for i in range(1,100000000+1):
    m += m * 0.01
    m = int(m)
    
   
    if m >= N:
      print(i)
      break

Solution (Python):
import math
X=int(input())
i=1
ans=100
while math.floor(ans*(1+0.01))<X:
    ans=math.floor(ans*(1+0.01))
    i+=1
print(i)

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

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

import math
money = 100
cou = 0

while money < X:
    money = math.floor(money*1.01)
    cou += 1

print(cou)

Solution (Python):
import math
import sys
X=int(input())
money=int()
money=100
i=1
while X<=10**18:
    money=math.floor(money*1.01)
    if money>=X:
        print(i)
        sys.exit()
    else:
        i=i+1

Solution (Python):
import math
X = int(input())
money = float(100)
year = 0
while 1:
    if money >= X: break
    money = math.floor(money+money*0.01)
    year += 1
print(year)

Solution (Python):
from copy import copy, deepcopy
from collections import Counter
from math import sqrt, floor, log

MOD = 10**9 + 7


X = int(input())

ans = 0
tmp = 100
while tmp < X:
    tmp = floor(tmp * 1.01)
    ans += 1

print(ans)

Solution (Python):
K = int(input())
i = 0
s = 100
while True:
  i = i + 1
  s = int(s * (1 + 0.01))
  
  if (K <= s):
    print(i)
    break

Solution (Python):
import math
X = int(input())
i = 2
Y = 100

for i in range(100000000000000000):
    Y = math.floor(Y*1.01)
    if Y >= X:
        print(i+1)
        break

Solution (Python):
import math
n = int(input())
s=100

for i in range(1,3761):
  s=math.floor(s*0.01+s)
  if s>=n:
    print(i)
    break

Solution (Python):
x = int(input())
tmp = 100
year = 0
while tmp < x:
  year += 1
  tmp = (tmp * 101) // 100

print(year)

Solution (Python):
from decimal import *
x = int(input())
a = 100
n=1
while (True):
    if int(a * 1.01) >= x:
        print(n)
        exit()
    else:
        a=int(a*1.01)
        n+=1

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

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

while ans != 100:
  ans = math.ceil(ans / 1.01)
  count += 1
  
print(count)

Solution (Python):
import math
x = int(input())
cur = 100
for i in range(1, 3761):
	cur = cur + math.floor((cur / 100))
	if (cur >= x):
		print(i)
		break

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

Solution (Python):

x = int(input())


now = 100
count = 0
while(now<x):
    now += now//100
    count+=1
print(count)

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

count = 0
while x > bank:
    bank = int(bank * 1.01)
    count += 1

print(count)

Solution (Python):
import sys
sys.setrecursionlimit(300000)

def I(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LMI(): return list(map(int, sys.stdin.readline().split()))
MOD = 10 ** 9 + 7
INF = float('inf')


X = I()
d = 100
for i in range(1, 3761):
    d = int(d * 1.01)
    if d >= X:
        print(i)
        exit(0)

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

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

Solution (Python):
k = int(input())
i = 100
cnt = 0
while i < k:
    p = float(i) 
    p = p * 1.01
    i = int(p)
    cnt = cnt + 1
print(cnt)

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

Solution (Python):
from decimal import Decimal

x = int(input())

s = 100
r = 0.01
i = 0
ans = 0
while not(s >= x):
    s = int(s * (1 + r))
    ans = i
    i += 1

print(ans + 1)

Solution (Python):
N = int(input())
n=0
k=0.01
sum=100
while N > sum:
    add=sum*0.01
    sum=sum+int(add)
    n=n+1
print(n)

Solution (Python):
import math

X = int(input())
temp = 100
i = 0

while(temp < X):
    ann_balance = math.floor(temp / 100)
    temp = temp + ann_balance
    i += 1

print(i)

Solution (Python):
from decimal import *
x=int(input())
c=0
m=100
while m<x:
  m=Decimal(str(m))*Decimal('1.01')
  m=int(m)
  c+=1
  
print(c)

Solution (Python):
x=int(input())
d=100
con=0
while x>d:
    con+=1
    d=int(d*1.01)

print(con)

Solution (Python):
import math

x = int(input())

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

print(year)

Solution (Python):
X=int(input())
sum=0
n=100
for i in range(10000):
    if n<X:
        n=n*1.01//1
        sum += 1
print(sum)

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

sum=0
y=100
for i in range(10000):
  y=int(y*1.01)
  if y<x:
    sum+=1
  else:
    sum=sum
print(sum+1)

Solution (Python):
import math

X = int(input())
temp = 100
i = 0

while(temp < X):
    ann_balance = math.floor(temp / 100)
    temp = temp + ann_balance
    i += 1

print(i)

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

ret = 100
ans = 0

while True:
    ret = ret * 101 // 100
    ans += 1
    if x <= ret:
        print(ans)
        break

Solution (Python):

def main():
    X = int(input())
    bank_money = 100
    i = 1
    while True:
        bank_money = int(bank_money * 1.01)
        if bank_money >= X:
            out = i
            break
        i += 1
    print(out)
main()

Solution (Python):
from math import floor
x=int(input())
p=100
r=0.01

for i in range(1,3760+1):
    c=floor(p*(1.01)**1)
    if c<x:
        p+=c-p
    else:
        break
print(i)

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

years = 0
money = 100
RISI = 0.01
while money < X:
	money += int(money * RISI)
	years += 1
print(years)

Solution (Python):
import math
a=int(input())
b=100
ans=0
while(1):
  b += math.floor(b*0.01)
  ans +=1
  if(b>=a):
    break



print(ans)

Solution (Python):
x = int(input())
a = 100
y = 0
while x > a:
    a = int(a*101/100)
    y = y+1
 
print(y)

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

x = int(input())

res = 0
c = 100


while c < x:
    c = (c*101)//100
    res += 1

print(res)

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

X = int(readline())

res = 100
for i in range(1, 10000):
    res = res*101//100
    if res >= X:
        break
print(i)

Solution (Python):
import math
a = int(input())
 
b = 100
ans = 0

while a > b:
    b = math.floor(b*1.01)
    ans += 1
 
print(ans)

Solution (Python):
import math
X = int(input())
count = 0
x_value = 100

while x_value < X:
  x_value += math.floor(x_value * 0.01)
  count += 1
  

print(count)

Solution (Python):
import math

x = int(input())
m = 100
i = 0.01
y = 0
flag = True
while flag:
    m = math.floor(m*(1+i))
    y += 1
    if m >= x:
        break
print(y)

Solution (Python):
counter = 0
x = int(input())
yokin = 100

while x > yokin:
  yokin = int(yokin * 1.01)
  counter += 1

print (counter)

Solution (Python):

import math

a = int(input())
x = 100
y = 1.01
count  = 0

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

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

Solution (Python):
import math

x = int(input())
cnt = 0
s = 100

while True:
    if (s >= x):
        break
    s = s+(math.floor(s*0.01))
    cnt += 1
print(cnt)

Solution (Python):
x = int(input())
depo = 100
y = 0

while depo < x:
    depo = int(depo * 1.01)
    y += 1

print(y)

Solution (Python):
def main(p):
    k=100
    a=0
    while k<p:
        k=(k+k*0.01)//1
        a+=1
    print(a)
p=int(input())   
main(p)

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

def rishi(yen):
	return int(yen * 1.01)

while 1:
	i += 1
	yen = rishi(yen)
	if X <= yen:
		break

print(i)

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

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

print(n)

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

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

money = 100
count = 0
while money < X:
    count += 1
    money = (money * 1.01) // 1

print(count)

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

Solution (Python):
def main():
    X=int(input())
    P=100
    countYears=0
    while(True):
        A=P+P*(0.01)
        A=int(A)
        countYears+=1
        P=A
        if A>=X:
            break
    print(countYears)
if __name__=='__main__':
    main()

Solution (Python):
X = int(input())
current = 100
year = 0
while current < X :
    fraction = current*0.01
    if fraction >= 1 :
        current = current + int(fraction)
        year = year + 1
print(year)

Solution (Python):
import math
X = int(input())
d = 100
year = 0
while True:
    year += 1
    if d+math.floor(d*0.01) >= X:
        print(year)
        exit()
    else:
        d += math.floor(d*0.01)

Solution (Python):
import math
X = int(input())
zankin = 100
for i in range(1,10**18):
  zankin += math.floor(zankin*0.01)
  if zankin >=X:
    print(i)
    break

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

Solution (Python):
import math
import sys

stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
mod = 10**9 + 7 
sys.setrecursionlimit(1000010)

X = ni()
S = 100
year = 0
while True:
    if S >= X:
        print(year)
        exit(0)
    S = (S * 101) // 100
    year = year +1

Solution (Python):
import math

x = int(input())

money=100


for year in range(1,100000):
    money = math.floor(money*1.01)
    if money>=x:
        print(year)
        break

Solution (Python):
import math
import sys

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

if X==y:
	print(i)
	sys.exit()

while X > y:
	i=i+1
	y=y*1.01
	y=math.floor(y)
	if X==y:
		print(i)
		sys.exit()

print(i)

Solution (Python):
import math
x = int(input())
m = x-100
ans = 100
i = 0
while(ans<x):
    ans += math.floor(ans*0.01)
    i+=1
print(i)

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

while True:
    if m >= x:
        break
    c += 1
    m = m + int(m*0.01)

print(c)

Solution (Python):
import math
x = int(input())
m = x-100
ans = 100
i = 0
while(ans<x):
    ans += math.floor(ans*0.01)
    i+=1
print(i)

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

Solution (Python):
import math

X = int(input())
money = 100
ret = 0
while X > money :
  money = int(money * 1.01)
  ret += 1
print(ret)

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

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

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

cnt = 0
total = 100

while True:
    cnt += 1
    total = (total*101)//100

    if total>=X:
        break

print(cnt)

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

num =  0
s = 100
while True :
    num += 1
    s += math.floor(s * 0.01)
    if  s >= x:
        break
    else:
        continue
print(num)

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

money = 100
i = 1

while money < x:
	money = int(money * 1.01)
	if money >= x:
		print(i)
	else:
		i = i+1

Solution (Python):
a=int(input())
m=100
c=0
for i in range(4000):
  m=int(m*1.01)
  c=c+1
  if m >= a:
    break
print(c)

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

Solution (Python):
X = int(input())
bank = 100
result = 0

import math
import decimal

while (True):
    
    if(bank >= X):
        break
    else:
        tmp = str(bank*0.01)
        tmp = tmp[:tmp.find('.')]
        bank = bank + int(tmp)
        result = result+1

print(result)

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

cnt = 0
while(money < X):
    cnt += 1
    money = math.floor(money*1.01)
print(cnt)

Solution (Python):
import math

X = int(input())
N = 1
Year = 0
money = 100

while(money < X):
    money = money + math.floor((money * 0.01))
    Year = N
    N=N+1

print(Year)

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

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

print(cnt)

Solution (Python):
n = int(input())
poket = 100
count = 0

while True:
    poket += int(poket*0.01)
    count += 1
    if(poket>=n):
        break
    
print(count)

Solution (Python):
import math
X = int(input())
v= math.log(X/100,1.01)
original = 100
tmp = original
Ny = 1 
while(1):
    tmp = tmp+tmp//100
    if tmp>=X:
        break
    else:
        Ny+=1

print(Ny)

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

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

main()

Solution (Python):
import math
x=int(input())
ans=100
y=1
while True:
    ans=math.floor(ans*1.01)
    if ans>=x:
        print(y)
        exit()
    y+=1

Solution (Python):
import math

x = int(input())
n = 100
for i in range(1, 100000):
    n = int(n * 1.01)
    if n >= x:
        print(i)
        exit()

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

x0=100
n=10**6
for i in range(n):
    x0=int(x0*1.01)
    if x0>=x:
        break
print(i+1)

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

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

print(count)

Solution (Python):
X = int(input())
Y = 100
i = 0
while(1):
    Y = int(Y * 1.01)

    i = i + 1
    if Y >= X:
        break
print(i)

Solution (Python):
import math
x = int(input())
m = 100
ans = 0
while m < x:
    m = math.floor(m + m * 0.01)
    ans += 1
    
print(ans)

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

Solution (Python):
import math

x = int(input())
n = 0
m = 100
while m < x:
    n += 1
    m = math.floor(m * 1.01)
print(n)

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

Solution (Python):
X = int(input())
n = 0
m = 100
while m < X:
    m += int(str(m)[:-2])
    n += 1
print(n)

Solution (Python):

import math

k = int(input())




n = 1
a=100
while a < k:
    a= math.floor(a*1.01)
    n+=1
if k<=100:
    print(n)
else:
    print(n-1)

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

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

print(year)

Solution (Python):
import numpy as np
X = int(input())
zandaka = 100
for a in range(100000):
    zandaka = np.floor(zandaka * 1.01)
    if zandaka >= X:
        print(a+1)
        break

Solution (Python):
import math
from decimal import Decimal

def next_year_depo(x):
    return (x * Decimal(1.01)).quantize(Decimal('1.'), rounding='ROUND_DOWN')

depo = Decimal(100)
target = int(input())

ans = math.floor(math.log(target/100, 1.01))
for _ in range(ans):
    depo = next_year_depo(depo)

while depo < Decimal(target):
    depo = next_year_depo(depo)
    ans +=1
print(ans)

Solution (Python):

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

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

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

Solution (Python):
import math

a = 100
x = int(input())

for i in range(x):
    if a < x:
        a = math.floor(1.01 * a)
    else:
        print(i)
        break

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

base = 100

count = 0

while base < x:
    base = int(base * (1.01))
    count += 1

print(count)

Solution (Python):
import math

X=int(input())
money=100
year=0

while money<X:
    new=money*1.01
    money=math.floor(new)
    year+=1
    
print(year)

Solution (Python):
X=int(input())
deposit=100
year=0
while(deposit<X):
  deposit=int(deposit/100)+deposit
  year=year+1

print(year)

Solution (Python):

import math

deposit = 100


target = int(input())

for n in range(1, 50000000):
    deposit = math.floor(deposit * 1.01)
    
    if (deposit >= target):
        print(n)
        break

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

v = 100
y = 0
while True:
    v *= 1.0100000
    v   = int(v)
    y += 1
    if v >= X:
        break
        
print(y)

Solution (Python):
import math
account = 100
goal = int(input())
count = 0

while True:
  count += 1
  account = math.floor(account * 1.01)
  if account >= goal:
  	break
print(count)

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

Solution (Python):
import math
x = int(input().strip())
a = 0
b = 100
c = 0
count = 0
list = []
while a ==0:
    list.append(b)
    b = math.floor(b*1.01)
    count = count + 1
    if b >= x:
        print(count)
        break

Solution (Python):
x = int(input())
y = 100
n = 0
while True:
  if y < x:
    y += int(0.01 * y)
    n += 1
  else:
    print(n)
    break

Solution (Python):
a = int(input())
b = 100
count = 0
while True:
  b = int(b + b*(0.01))
  count += 1
  if b >= a:
    break
print(count)

Solution (Python):
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
    if row <= 0:
        return [[] for _ in range(col)]
    elif col == 1:
        return [I() for _ in range(row)]
    else:
        read_all = [LI() for _ in range(row)]
        return map(list, zip(*read_all))



X = I()

now = 100
count = 1
while True:
    now = math.floor(1.01*now)
    if now >= X:
        print(count)
        exit()
    count += 1

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

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

while 101 <= X <= 10**18:
    depo = 100
    year = 1
    while True:
        depo += math.floor(depo * 0.01)
        if depo >= X:
            print(year)
            break
        year += 1
    break

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

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

Solution (Python):
import math
import sys

targ=int(input())
first=100
rate=1.01
year=0
for i in range(100000):
  first*=rate
  first=first//1
  year+=1
  if first>=targ:
    print(year)
    sys.exit()

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

Solution (Python):
a = int(input())
b = 100
c = 0
while b < a:
    b = b +b//100
    c = c+1
print(c)

Solution (Python):



def inp():
    return(int(input().rstrip()))
def inlt():
    return(list(map(int,input().rstrip().split())))
def insr():
    s = input().rstrip()
    return(s[:len(s) - 1])
def invr():
    return(map(int,input().rstrip().split()))

k = 100
x = inp()
for i in range(5000):
    temp = k + k * 0.01
    k = int(temp)
    if k >= x:
        break

print(i + 1)

Solution (Python):
import math
X = int(input())
Amount = 100
for i in range(1, 10**18+1): 
    Amount += math.floor(Amount * 0.01)
    if Amount >= X:
        print(i)
        break

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

Solution (Python):
x = int(input());
count = 0;
v = 100;
while(v < x):
    r = int(v * 0.01);
    v += r;
    count += 1;

print(count);

Solution (Python):
X = int(input())
n = 100
A = 100
i = 0

while n < X:
    n = A*1.01
    A = int(n)
    i += 1
    if A >= X:
        print(i)
        break

Solution (Python):
x = int(input(" "))
A = 100
n = 1
while (1):
    A = int(A*1.01)
    if (A >= x):
        print(n)
        break
    n += 1

Solution (Python):
try:
	x=int(input())
	o=100
	count=0
	while o<x:
		o=int(o+(o*(1/100)))
		count+=1
	print(count)
except:
	pass

Solution (Python):
from math import floor

X, val, a = eval(input()), 100, 1

while True :
    val += floor(val * 0.01)
    if val >= X:
        break
    a += 1
print(a)

Solution (Python):
import math
def resolve():
    x=int(input())
    n=100
    count=int(0)
    while n<x:
        n=n*1.01
        n=math.floor(n)
        count+=1
    print(count)

resolve()

Solution (Python):
import math
x=int(input())
a=100
for i in range(1,3761):
    a=int(1.01*a)
    if a>=x:
        print(i)
        break

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

Solution (Python):
import math
a=int(input())
pq=100
for i in range(4000):
    pq=pq*((1+.01*1))//1
    
    
    if (pq)>=a:
        print(i+1)
        break

Solution (Python):
X = int(input())
Amount = 100
Year = 0
while Amount < X:
    P = Amount * 0.01
    if P >= 1:
        Amount+= int(P)
        Year+=1
print(Year)

Solution (Python):
X = int(input())
r = 0.01
s = 100
i = 0
while s < X:
    s = int(s * (1 + r))
    i = i + 1
else:
    print(i)

Solution (Python):
x=int(raw_input())
amt=100
i=0
while True:
	amt=amt*1.01
	amt=amt//1
	i+=1
	if amt>=x:
		print(i)
		exit(0)

Solution (Python):
from math import floor

a = int(input())
n = 100
result = 0

while True:
    n = floor(n) * 1.01
    result += 1
    if n >= a:
        break

print(result)

Solution (Python):
from math import log
from math import floor
X = int(input())

res = 100
k = 0
while True:
  if res >= X:
    print(k)
    exit()
  else:
    k += 1
    res = floor(res * 1.01)

Solution (Python):
X= int(input())
Y = int(100)
count= 0

while Y<X:
  Y=int(Y*1.01)
  count += 1
  
print(count)

Solution (Python):
X = int(input())
Answer = 0
S = 100
while True:
    S += (S//100)
    Answer += 1
    if X <= S:
        break
print(Answer)

Solution (Python):
if __name__ == "__main__":
    X = int(input())
    year = 0
    money = 100
    while money < X:
        year += 1
        money = int(money*1.01)
    print(year)

Solution (Python):
target = int(input())
now = 100
count = 0

while True:
    if(now >= target):
        break
    count += 1
    now = int(now * 1.01)
    

print(count)

Solution (Python):
x = int(input())
a = 100
count = 0
for i in range(10**18):
    a = int(a * 1.01)
    count = count + 1
    if int(a) >= x:
        d = count
        break
print(d)

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


total = 100
count = 1
while total < X:
    total = int(total*1.01)
    count+=1
print(count-1)

Solution (Python):
import math

X = int(input())
Takahashi_money =100
num = 0

while Takahashi_money < X:
    Takahashi_money = Takahashi_money * 1.01
    Takahashi_money = math.floor(Takahashi_money)
    num += 1

print(num)

Solution (Python):



import math

x = int(input())

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

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

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

Solution (Python):
x = int(int(input()))
base = 100
count = 0
while(x > base):
    base += base // 100
    count += 1
print(count)

Solution (Python):
import math

X=int(input())
n=100
num=0

while n<X:
  n=n*1.01
  n=math.floor(n)
  num+=1
  
print(num)

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

num = 100
i = 0
while True:
    if num >= X:
        break
    sun = num  // 100
    num += sun
    i += 1
print(i)

Solution (Python):
import math

x = int(input())

ans = 100
cnt = 0

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

print(cnt)

Solution (Python):
import math
x = int(input())
n = int((math.log10(x)-2)/math.log10(1.01))-1
total = 100
while total < x:
    n += 1
    total = 100
    for _ in range(n):
        total += int(total*0.01)
print(n)

Solution (Python):
import math

A = int(input())

n = 100
num = 0
while n < A:
  n = math.floor(n*1.01)
  num = num + 1
  
print(num)

Solution (Python):
import math
K = input()
K = float(K)
X = 100.0
i = 0
while K > X:
  X = X *1.01
  X = math.floor(X)
  i = i + 1

  
print(i)

Solution (Python):
X = int(input())
current1 = 100
year = 0
while current1 < X :
    fraction = current1*0.01
    if fraction >= 1 :
        current1 = current1 + int(fraction)
        year = year + 1
print(year)

Solution (Python):

import sys
x = int(input())
c = 1
r = True
p = 100

while r == True:
    if int(p*1.01) >= x:
        print(c)
        sys.exit()
    else:
        p = int(p*1.01)
        c += 1

Solution (Python):
import math

X = int(input())

m = 100
z=0

while X > m:
    m = m * 1.01
    z = z + 1
    m = math.floor(m)


print(z)

Solution (Python):




X = int(input())


yokin = 100
i=0
while(yokin < X):
    yokin = int(yokin*1.01)
    
    i=i+1



print(i)

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

total=100
cnt=1

while True:
    total *= 1.01
    total = int(total)
    if x <= total:
        print(cnt)
        exit()

    cnt+=1

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

Solution (Python):
import math
x = int(input()) 
a = 100
for i in range (1,10**18):
    a = a + math.floor(a*0.01)
    if a >= x:
        print(i)
        break

Solution (Python):
import math
listA=[] 
while True:
    try:
        listA.append(list(map(int,input().split())))

    except:
        break;
        

x = listA[0][0]
r = 100
for i in range(1, 10**180):
  r = math.floor(r*1.01)
  if r >= x:
    print(i)
    break

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

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

b = 100
c = 0

while b < X:
    b = int(b*1.01)
    c += 1

print(c)

Solution (Python):
import os
import sys
from collections import deque
from collections import Counter
from heapq import heappop,heappush
import math

def main():
	money = int(input())	
	yokin = 100
	count = 0
	while yokin < money:
		yokin = yokin + math.floor((1/100)*yokin)
		count += 1
	print(count)


if __name__ == "__main__":
        main()

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

count = 0
flag = True
while flag:
  yokin = yokin * (1.01)
  yokin = int(yokin)
  count += 1
  if int(yokin) >= x:
    print(count)
    flag = False

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

print(y)

Solution (Python):
X = int(input())
current = 100
year = 0
while current < X :
    fraction = current*0.01
    if fraction >= 1 :
        current = current + int(fraction)
        year = year + 1
print(year)

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