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 = 0
b = 100

while b < x:
    b += int(0.01*b)
    i += 1

print(i)

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

deposit = 100
count = 0
while deposit < X:
    deposit = int(deposit * 1.01)
    count += 1
print(count)

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

while total < X:
    total = total + int(0.01 * total)
    year += 1
    
print(year)

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

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

Solution (Python):
X=int(input())
n=100
for i in range(10000):
    if n>=X:
        print(i)
        exit()
    n+=n//100

Solution (Python):
x = int(input())
y = 100
for i in range(4000):
    if y >= x:
        print(i)
        break
    y += y//100

Solution (Python):
X = int(input())
S=100
for i in range(1,10**18):

    S=int(S*1.01)
    if S>=X:
        
        break
print(i)

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

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

a, y = 100, 0

while a < x:
    y += 1
    a += int(a * 0.01)

print(y)

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

def multiple_year(n): 
    money = int(n * 101 / 100)
    return money

money = 100 
year = 0
while X > money :
    money = multiple_year(money)
    year = year + 1
print(year)

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

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

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

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

def LI(): return list(map(int, stdin.readline().split()))
def LS(): return list(stdin.readline())

import math
a = 100
x = int(input())
cnt = 0
while True:
    a = math.floor(a*1.01)
    cnt += 1
    if a>=x:
        break
print(cnt)

Solution (Python):
import math
X = int(input())
dep = 100
ans = 0
while X > dep:
    dep = math.floor(dep * 1.01)
    ans += 1
print(ans)

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

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

Solution (Python):

X = int(input())






n = 0
money = 100
while money < X:
    money *= 1.01
    money = int(money)
    n += 1

print(n)

Solution (Python):
import math
k = int(input())
y = 100
count = 0
while True:
    if y >= k:
        print(count)
        exit()
    y += math.floor(y * 0.01)
    count += 1

Solution (Python):
x,y,a=int(input()),100,0
while y<x: y+=y//100; a+=1
print(a)

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

while d < x:
    d += d // 100
    ans += 1

print(ans)

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

Solution (Python):
from sys import setrecursionlimit, exit
setrecursionlimit(1000000000)

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

main()

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

print(cnt)

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

Solution (Python):

import sys
sys.setrecursionlimit(10**8)
INF = float("inf")


def solve(X: int):

    
    s = 100
    cnt = 0
    while X > s:
        cnt += 1
        s = int(s*1.01)
    print(cnt)
    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):
x = int(input())
ans = 0
a = 100

while a < x :
    a += a//100
    ans += 1

print(ans)

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

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

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

m = 100
y = 0

while m < x:
    m = int(m + m*0.01)
    y += 1

print(y)

Solution (Python):
import math
X = int(input())
deposit = 100
cnt = 0
for i in range(1,100**18):
    deposit = math.floor(deposit * 1.01)
    cnt += 1
    if deposit >= X:
        break
print(cnt)

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

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

print(year)

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

Solution (Python):
def main():
    X = int(input())
    money = 100
    n = 0
    while True:
        n += 1
        money = int(1.01*money)
        if money >= X:
            print(n)
            break

if __name__ == '__main__':
    main()

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

Solution (Python):
x=int(input())
y=int(100)
for i in range(0,99999999):
    y=int(y*1.01)
    if x<=y:
        break
print(i+1)

Solution (Python):
import math

x = int(input())

credit = 100
ans = 0
while True:
    credit = math.floor(credit * 1.01)
    ans += 1

    if credit >= x:
        break
print(ans)

Solution (Python):
import math


X = int(input())

A = 100
i = 0

while True:
    if X <= A :
        print(i)
        break
    else:
        i += 1
        A = math.floor(A*1.01)

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

money = 100
count = 0

while money<x:
    a = money//100
    money += a
    count += 1

print(count)

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

Solution (Python):
x = int(input())
base = 100
year = 0
while True:
    year = year + 1
    base = int(base * 1.01)
    if x <= base:
        print(year)
        break

Solution (Python):


x = int(input())
base = 100
year = 0
while True:
    year = year + 1
    base = int(base * 1.01)
    if(x <= base):
        print(year)
        break

Solution (Python):


x = int(input())
base = 100
year = 0
while True:
    year +=  1
    base = int(base * 1.01)
    if(x <= base):
        print(year)
        break

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

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

while Y < X:
    Y = Y + (Y // 100)
    i = i + 1

print(i)

Solution (Python):


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

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

Solution (Python):


x = int(input())
base = 100
year = 0

while True:
    year = year + 1
    base = int(base * 1.01)
    if x <= base:
        print(year)
        break

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

Solution (Python):
import math

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

while a<X:
  a *= 1.01
  a = math.floor(a)
  y += 1
  
print(y)

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

Solution (Python):
import  math

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

while money < a:
  money = math.floor(money * 1.01)
  year += 1

print(year)

Solution (Python):
def resolve():
	s = 100
	x = int(input())
	step = 0
	while s < x:
		step += 1
		s += s // 100
	print(step)
resolve()

Solution (Python):
import sys
import os
import math
import bisect
import collections

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]

lcm = lambda x, y: x * y / math.gcd(x, y)

MOD = 10 ** 9 + 7
MAX = float('inf')


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    X = ii()
    x = 100
    ret = 0
    while x < X:
        ret += 1
        x += x // 100
    print(ret)


if __name__ == '__main__':
    main()

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

p=100.0
ans=0
while p<x:
	p+=(p//100)
	ans+=1
print(ans)

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

Solution (Python):




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

    cnt = 0
    result = 100
    while X > result:
        result = int(result * 1.01)
        cnt += 1

    print(cnt)


if __name__ == "__main__":
    main()

Solution (Python):
import math
X=int(input())
origin=100
count=0
while(origin<X):
    origin+=int(origin*0.01)
    count+=1
print(count)

Solution (Python):
from collections import defaultdict

import sys
sys.setrecursionlimit(10**6)
ii = lambda: int(input())
mis = lambda: map(int,input().split())
lmis = lambda: list(mis())
INF = float('inf')

def main():
    x=ii()
    ttl=100
    cnt=0
    while ttl<x:
        ttl+=ttl//100
        cnt+=1
    print(cnt)

if __name__ == "__main__":
    main()

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

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

for i in range(1,10**5):
    h = int(h*1.01)
    if x<=h:
        print(i)
        exit(0)

Solution (Python):
import math

x = int(input())
money = 100
cnt = 0
while money < x:
    money = math.floor(money*1.01)
    cnt += 1
    if money == x:
        break
    else:
        pass

print(cnt)

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

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

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

print(ans)

Solution (Python):
import math

X = int(input())

yokin = 100
years = 0
while yokin < X:
    years = years + 1
    yokin = math.floor(yokin * (1 + 0.01))

print(years)

Solution (Python):
import numpy as np
import math
x = int(input())
ans = 0
now = 100

for i in range(1,10**100):
    now = int(now*1.01)
    if now >= x:
        ans = i
        break

print(ans)

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

money, cnt = 100, 0
while money < x:
    money += money // 100
    cnt += 1

print(cnt)

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

import math


def calcX(n):
  X = 100
  for i in range(n):
    X = math.floor(X * 1.01)
  return X

year = 0
while True:
  if X > calcX(year):
    year += 1
  else:
    print(year)
    break

Solution (Python):
n=int(input())
ans=100
mod=1000000007
for i in range(1,mod):
    ans=ans+(ans//100)
    if ans>=n:
        print(i)
        exit()

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

x = int(input())

money = 100
count = 0

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

print(count)

Solution (Python):
x = int(input())
n = 0
s = 100

while s<x :
    s += int(s*0.01)
    n += 1

print(n)

Solution (Python):
import sys


x = int(sys.stdin.readline().rstrip())
def main():
    y = 100
    cnt = 0
    while True:
        y = y * 1.01 // 1
        cnt += 1
        if y >= x:
            print(cnt)
            return
if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):

x=float(input())
p=100.0
s=0
while p<x:
 p+=p//100
 s+=1
print(s)

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

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

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

while now < X:
  now *= 1.01
  
  now -= now%1
  year += 1

print(year)

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

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

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

import math

count = 0
price = 100

while X > price:
    count += 1
    price = math.floor(price*1.01)
print(count)

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

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

Solution (Python):
import math

X=int(input())

x,y=100,0
while x<X:
  x=math.floor(x*1.01)
  y+=1

print(y)

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

money= 100
i= 0
while money<x:
        money += money //100
        i += 1

print(i)

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

yokin = 100
n = 0

while True:
    yokin = yokin * 1.01 // 1
    n += 1
    if yokin >= X:
        print(n)
        break

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

while(x > s):
    s += s // 100
    y += 1

print(y)

Solution (Python):
def main():
    X = int(input())
    import math
    i = 0
    sum = 100

    while sum < X:
        sum = int(sum * 1.01)
        i += 1

    print(i)


main()

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

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

while a < x:
  a += a//100
  y += 1

print(y)

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

Solution (Python):
X = int(input())
yokin = 100
for i in range(1, 4000):
    yokin = yokin * 101 // 100
    if yokin >= X:
        print(i)
        break

Solution (Python):
import math

X= int(input())

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

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

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

print(ans)

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


Y = 0
Z = 100
while Z < X:
  Z += Z//100
  Y+=1

print(Y)

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

Solution (Python):


X = int(input())


def main() -> None:
    """Entry point
    """
    
    
    deposit = 100
    year = 0
    while deposit < X:
        deposit += deposit // 100
        year += 1

    
    print(year)


if __name__ == "__main__":
    main()

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

amt = 100
ans = 0
while amt < X:
    amt += amt //100
    ans += 1

print(ans)

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

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

print(y)

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

while now < X:
    now += now // 100
    ans += 1

print(ans)

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

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

Solution (Python):
import math

X = int(input())

P = 100
step = 0

while P < X:
  P += math.floor(P / 100)
  step += 1

print(step)

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

Solution (Python):
import math


X = int(input())

money = 100

years = 0

while money < X:
    money = int(money * 1.01)
    years = years + 1


print(years)

Solution (Python):
import math

x = int(input())

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

print(ans)

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

while A<X:
    A = int(A*1.01)
    N += 1

print(N)

Solution (Python):
import time
startTimeProblem=time.time()

import fileinput, sys, itertools, functools
from math import *
from bisect import *
from heapq import *
from collections import *

def lcm(a, b):  
    return (a*b)/gcd(a, b)

class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()]

class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st)

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None

In = InputHelper()
Out = OutputHelper()



X = In.int()

cur = 100
steps = 0
while cur<X:
    cur += cur//100
    steps+=1

Out.int(steps)
        


if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
    fin = (time.time()-startTimeProblem)*1000
    print("{:.2f}".format(fin) + "ms")

Solution (Python):
import math

def solve():
    x = int(input())
    m = 100
    ans = 0
    while True:
        if m >= x:
            print(ans)
            break
        m *= 1.01
        m = math.floor(m)
        ans += 1
    return 0

if __name__ == "__main__":
    solve()

Solution (Python):




x = int(input())
p = 100
i = 0
while p < x:
    p += int(p / 100)
    i += 1

print(i)

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

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

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

Solution (Python):

INF = 2**62-1


def read_int():
    return int(input())


def slv(X):
    T = 100
    for i in range(INF):
        T += T // 100
        T = int(T)
        if X <= T:
            return i + 1


def main():
    X = read_int()
    print(slv(X))


if __name__ == '__main__':
    main()

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

while x > balance :
    balance += balance//100
    cnt += 1

print(cnt)

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

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

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print('\n'.join(map(str, x)))

X = int(input())
v = 100

cnt = 0
while v<X:
    v = v*101//100
    cnt += 1

print(cnt)

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

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



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

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

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

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

Solution (Python):
deposit = 100
interest = 1.01
target_deposit = int(input())
count_year = 0

while deposit < target_deposit:
  deposit += int(deposit/100)
  count_year += 1

print(count_year)

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

ans = 0
y = 100
while y < x:
    y = y * 101 // 100
    ans += 1

print(ans)

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

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

Solution (Python):
import math

Y = int(input()) 

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

Solution (Python):
A=int(input())
count=0
money=100

while money<A:
    money=int(money*1.01)
    count=count+1

print(count)

Solution (Python):
def run():
  X = int(input())
  bal = 100
  year = 0
  
  while bal<X:
    bal += int(bal*0.01)
    year += 1
  
  print(year)
  
if __name__ == "__main__":
  run()

Solution (Python):
X = int(input())
money = 100
ans = 1
for i in range(1,3761):
    money = int(money*1.01)
    if money >= X:
        break
    else:
        ans += 1

print(ans)

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

for i in range(100000):
    m = m*101//100
    year += 1
    if m >= x:
        print(year)
        exit()

Solution (Python):
x,m=int(input()),100
for d in range(4000):
 m+=m//100
 if x<=m:print(d+1);exit()

Solution (Python):
import math
N = int(input())
y = 0
kekka = 100
while True:
    y +=1
    kekka = int(kekka * 1.01)
    if kekka >= N:
        break
print(y)

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

m=100
for i in range(1,10001):
  m+=m//100
  if x<=m:print(i);exit()

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

cnt = 1
m = 100
while True:
    m += int(0.01 * m)
    if m >= X:
        print(cnt)
        break
    else:
        cnt += 1

Solution (Python):
x = int(input())
m = 100
for i in range(1, pow(10, 5)):
    m *= 1.01
    m = int(m)
    if m >= x:
        print(i)
        exit()

Solution (Python):
import sys,bisect,string,math,time,functools,random
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
from itertools import permutations,combinations,groupby
def Golf():*a,=map(int,open(0))
def I():return int(input())
def S_():return input()
def IS():return input().split()
def LS():return [i for i in input().split()]
def LI():return [int(i) for i in input().split()]
def LI_():return [int(i)-1 for i in input().split()]
def NI(n):return [int(input()) for i in range(n)]
def NI_(n):return [int(input())-1 for i in range(n)]
def StoLI():return [ord(i)-97 for i in input()]
def ItoS(n):return chr(n+97)
def LtoS(ls):return ''.join([chr(i+97) for i in ls])
def GI(V,E,ls=None,Directed=False,index=1):
    org_inp=[];g=[[] for i in range(V)]
    FromStdin=True if ls==None else False
    for i in range(E):
        if FromStdin:
            inp=LI()
            a,b,c=(inp+[1])[:3]
            org_inp.append(inp)
        else:
            index=0
            a,b,c=(ls[i]+[1])[:3]
        if index==1:a-=1;b-=1
        aa=(a,c);bb=(b,c);g[a].append(bb)
        if not Directed:g[b].append(aa)
    return g,org_inp
def GGI(h,w,search=None,replacement_of_found='.',mp_def={'

    mp=[boundary]*(w+2);found={}
    for i in range(h):
        s=input()
        for char in search:
            if char in s:
                found[char]=((i+1)*(w+2)+s.index(char)+1)
                mp_def[char]=mp_def[replacement_of_found]
        mp+=[boundary]+[mp_def[j] for j in s]+[boundary]
    mp+=[boundary]*(w+2)
    return h+2,w+2,mp,found
def TI(n):return GI(n,n-1)
def bit_combination(k,n=2):
    rt=[]
    for tb in range(n**k):
        s=[tb//(n**bt)%n for bt in range(k)];rt+=[s]
    return rt
def show(*inp,end='\n'):
    if show_flg:print(*inp,end=end)

YN=['YES','NO'];Yn=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase

input=lambda: sys.stdin.readline().rstrip()

class Comb:
    def __init__(self,n,mo=10**9+7):
        self.fac=[0]*(n+1)
        self.inv=[1]*(n+1)
        self.fac[0]=1
        self.fact(n)
        for i in range(1,n+1):
            self.fac[i]=i*self.fac[i-1]%mo
            self.inv[n]*=i
            self.inv[n]%=mo
        self.inv[n]=pow(self.inv[n],mo-2,mo)
        for i in range(1,n):
            self.inv[n-i]=self.inv[n-i+1]*(n-i+1)%mo
        return
    
    def fact(self,n):
        return self.fac[n]
        
    def invf(self,n):
        return self.inv[n]

    def comb(self,x,y):
        if y<0 or y>x:
            return 0
        return self.fac[x]*self.inv[x-y]*self.inv[y]%mo

class Tree:
    def __init__(self,inp_size=None,init=True):
        if init:
            self.stdin(inp_size)
        return

    def stdin(self,inp_size=None):
        if inp_size==None:
            self.size=int(input())
        else:
            self.size=inp_size
        self.edges,_=GI(self.size,self.size-1)
        return
    
    def listin(self,ls):
        self.size=len(ls)+1
        self.edges,_=GI(self.size,self.size-1,ls)
        return

    def __str__(self):
        return  str(self.edges)

    def dfs(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append(x)
        v=[-1]*self.size
        v[x]=root_v
        while q:
            c=q.pop()
            for nb,d in self.edges[c]:
                if v[nb]==-1:
                    q.append(nb)
                    v[nb]=func(v[c],nb,d)
        return v

    def EulerTour(self,x,func=lambda prv,nx,dist:prv+dist,root_v=0):
        q=deque()
        q.append((-1,x))
        v=[None]*self.size
        v[x]=root_v
        et=[]
        while q:
            cb,ce=q.pop()
            et.append(ce)
            for nb,d in self.edges[ce]:
                if v[nb]==None:
                    q.append((nb,ce))
                    q.append((ce,nb))
                    v[nb]=func(v[ce],nb,d)
        vid=[[-1,-1]for i in range(self.size)]
        for i,j in enumerate(et):
            if vid[j][0]==-1:
                vid[j][0]=i
            else:
                vid[j][1]=i
        return v,et,vid
    
    def LCA_init(self,depth,et):
        self.st=SegTree(self.size*2-1,func=min,ide=inf)
        for i,j in enumerate(et):
            self.st.update(i,j)
        self.LCA_init_stat==True
        return
    
    def LCA(self,root,x,y):
        if self.LCA_init_stat==False:
            depth,et,vid=self.EulerTour(root)
            self.LCA_init(depth,et)
        return self.st.query(x,y+1)

show_flg=False
show_flg=True

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

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

x = 100
ans = 0
while x < X:
    x = int(float(x) * 1.01)
    ans += 1

print ans

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

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

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

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

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

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

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

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

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

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

Solution (Python):
import math

def read_input():
    return int(input())

def solve(X):
    n = 0
    balance = 100.0
    while balance < X:
        balance = math.floor(balance * 1.01)
        n += 1
    ans = n
    print(ans)

def main():
    X = read_input()
    solve(X)


if __name__ == "__main__":
    main()

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())
g = 100
c = 0
while g<x:
  g = (g + (g // 100))
  c += 1
print(c)

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

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

x = int(input())
n = 100
cnt = 0
while x > n:
    n = int(1.01*n)
    cnt += 1
print(cnt)

Solution (Python):

def main():
    X = int(input())
    cur, years = 100, 0
    while cur < X:
        cur = int(cur * 1.01)
        years += 1
    print(years)


if __name__ == "__main__":
    main()

Solution (Python):
x=int(input())
n=100
for i in range(1,1000000):
  n+=n//100
  if n>=x:
    print(i)
    break

Solution (Python):
from decimal import Decimal
x=int(input())
m=100
c=0
while m<x:
    c+=1
    m+=m/100
    m=int(m)
    
    

print(c)

Solution (Python):
x = int(input())
money = 100
days = 0

while x > money:
    money = int(money * 1.01)
    days += 1

print(days)

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

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

Solution (Python):
import sys
x = int(input())
bef = 100
i = 1
while True:
    ans = int(bef*1.01)
    if ans >= x:
        print(i)
        sys.exit()
    bef = ans
    i += 1

Solution (Python):
import numpy as np

X=np.array(input(),dtype=np.int64)

P=100
step=0
while(P<X):
    P+=P//100
    step+=1

print(step)

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

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

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

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

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

while ans < X:
    year += 1
    ans = int(ans*1.01)
print(year)

Solution (Python):
n=int(input())
x=100
for i in range(10000000000):
  x=int(1.01*x)
  if x>=n:
    print(i+1)
    break

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

Solution (Python):
import itertools


x = int(input())

money = 100
c = itertools.count()
while money < x:
    next(c)
    money = int(money * 1.01)

print(next(c))

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