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())

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

Solution (Python):

X = int(input())
A = 100
i = 1
while True:
    A = int(A * 1.01)
    if A >= X:
        break
    i = i + 1
print(i)

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

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

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

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

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

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

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

Solution (Python):


def solve():
    X = int(input())
    a = 100

    ans = 0
    if a >= X:
        print(ans)
        return

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

if __name__ == "__main__":
    solve()

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

Solution (Python):
from collections import *
x = int(input())
p = 100
y = 0
while(p < x):
	p = p*1.01//1
	y += 1
print(y)

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

sm = 100
count = 0

while 1:
    count += 1
    sm += int(0.01*sm)
    if sm >= x:
        break

print(count)

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

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

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

Solution (Python):
import math

K = int(input())

c = 0
a = 100

while(True):
    c = c + 1
    a = math.floor(a*1.01)
    if a >= K:
        break

print(c)

Solution (Python):
N=int(input())
i=100
j=1
while 1:
    i=int(i*1.01)
    if i >=N:
        print(j)
        break
    j+=1

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

for i in range(1, (10**18)):
    
    money = int(money*1.01)
    if money >= x:
        year = i
        break

print(year)

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

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

Solution (Python):
import sys
input = sys.stdin.readline
def main():
    x = int(input())
    t = 0
    a = 100
    while a < x:
        t += 1
        a = a+a//100
    print(t)

if __name__ == "__main__":
    main()

Solution (Python):
import sys

x = int(input())

INF = 1000000000000000000

a = 100

for i in range(1, INF):
    a = int(a*1.01)
    if a >= x:
        print(i)
        sys.exit()

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

Solution (Python):

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

if __name__ == '__main__':
    main()

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

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

money = 100
ans = 1
while True:
    money += int(money*0.01)
    if money >= x:
        break
    ans += 1

print(ans)

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

ans = 0
total = 100

while total < i:
  total = total + (total//100)
  ans +=1
  

print(ans)

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

print(t)

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



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


print(i)

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

Solution (Python):


X = int(input())


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


print(year)

Solution (Python):
import sys
import math
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()))

X=int(input())
c=0
m=100
while(m<X):
    m=math.floor(m*1.01)
    c+=1

print(c)

Solution (Python):
import math


def read():
    X = int(input())
    return X,

def solve(X):
    a = 100
    t = 0
    while a < X:
        a = math.floor(a * 1.01)
        t += 1
    return t
    

if __name__ == '__main__':
    inputs = read()
    print("{}".format(solve(*inputs)))

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

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

Solution (Python):
x = int(input())
r = 100
cnt = 0
while(1):
    r = int(r * 1.01)
    cnt += 1
    if r >= x:
        break

print(cnt)

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

i = 100
count = 0

while X > i:
  count += 1
  i = int(1.01*i)
  
print(count)

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


if __name__ == "__main__":
    main()

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

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

year = 0
yen = 100
while not (yen >= X):
    
    yen += int(yen*0.01)
    year += 1

print(year)

Solution (Python):
import math

x = int(input())

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

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

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

Solution (Python):
import math


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

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

    print(y)


if __name__ == '__main__':
    main()

Solution (Python):
import math

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

Solution (Python):
import math

x = int(input())

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

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

Solution (Python):

x = int(input())
c = 100
for i in range(4000):
    c += c//100
    if c >= x:
        print(i+1)
        break

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

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

m = 100
cnt = 0

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

Solution (Python):
import numpy as np
a=int(input())
n=100
count = 0
while n<a:
  n = int(1.01*n)
  count += 1
  
print(count)

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

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

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

Solution (Python):
k=int(input())
ans=100
y=0
while(1):
    if ans>=k:
        break
    m=(ans)//100 
    ans+=m 
    y+=1
    
print(y)

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

tmp = 100
for i in range(1,1000000):
    tmp = tmp + int(tmp * 0.01)
    if n <= tmp:
        print(i)
        exit()

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

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

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

while(money < X):
  money = money * 101 // 100
  num += 1
print(num)

Solution (Python):

import sys
import math


def solve(X: int):
    ans = 100
    cnt = 0
    while ans < X:
        ans += math.floor(ans * 0.01)
        cnt += 1
    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())

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

Solution (Python):
X = int(input())
a1 = 100
year = 1
while True:
    a2 = a1+int(a1*0.01)
    if a2 >= X:
        print(year)
        break
    a1 = a2
    year += 1

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

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

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

Solution (Python):
import math

X = int(input().strip())
v = 100

y = 0
while True:
    y += 1
    v = math.floor(v * 1.01)
    if v >= X:
        break
print(y)

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

ctr = 0
save = 100

while X > save:
    save = int(save + (save*0.01))
    ctr += 1

print(ctr)

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

while a < x:
    year += 1
    a = a * 101 // 100

print(year)

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

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())
n = 100
a = 0
while n < X:
    n = int(n * 1.01)
    a = a + 1
print(a)

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

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

for i in range(5000):
    fukuri = int(ans * 0.01)
    ans += fukuri
    if ans >= x:
        print(i+1)
        break

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


import math

x = int(input())
money = 100
i = 1

while True:
	money *= 1.01
	money = math.floor(money)
	
	if money >= x:
		print(i)
		break
	else:
		i += 1

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

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

Solution (Python):
k = int(input())
flag = True
kane = 100
count = 0
while flag:
    count += 1
    rishi = int( kane * 0.01 )
    kane += rishi
    if kane >= k:
        break
print(count)

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

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

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

now = 100
cnt = 0
while now < dep:
  now += int(now*0.01)
  cnt += 1
print(cnt)

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

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

print(ans)

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

a = 100
i = 0

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

print(i)

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

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

print(cnt)

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

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

print(ans)

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

now = 100
r = int(now * 0.01)
i = 1

while True:
    now += r

    if now >= x:
        print(i)
        break
    else:
        i += 1
        r = int(now * 0.01)

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

t = 0
m = 100
while 1:
    t += 1
    m = int((m * 101 + 0.1) // 100)
    if (m >= x):
        print(t)
        exit()

Solution (Python):


import sys





















def main():
    mod = 1000000007                
    inf = float('inf')              
    inf = 2 ** 64 - 1               
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    x = ii()
    year = 0
    money = 100
    while money < x:
        money = (money * 1.01) // 1
        year += 1
    print(year)


if __name__ == "__main__":
    main()

Solution (Python):

from sys import stdin
from operator import itemgetter
from collections import deque, Counter
import math
import pprint
from functools import reduce


MOD = 1000000007

def keta(kazu):
    kazu_str = str(kazu)
    kazu_list = [int(kazu_str[i]) for i in range(0, len(kazu_str))]
    return kazu_list

def gcd(*numbers):
    return reduce(math.gcd, numbers)

def combination(m,n):
    if n > m:
        return 'すまん'
    return math.factorial(m) // (math.factorial(m-n) * math.factorial(n))

def main():
    goal = int(stdin.readline().rstrip())
    kane = 100
    count = 0
    while kane < goal:
        count += 1
        kane = int(kane * 1.01)
    print(count)
    
main()

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

abc165_b()

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

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

amount = 100
year = 0
while amount < X:
  year += 1
  amount += math.floor(amount * 0.01)
  
print(year)

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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 9)
input = sys.stdin.readline
from itertools import permutations,  combinations, accumulate
from functools import *
from collections import deque, defaultdict, Counter
from heapq import heapify, heappop, heappush, heappushpop

INF = float('inf')
NIL = - 1

""" Input
S = input().rstrip()
N, A, B = map(int, input().split())
A = list(map(int, input().split()))
A = np.array(input().split(), dtype=np.float64)
D = [int(input()) for _ in range(N)]
AB = [[int(x) for x in input().split()] for _ in range(N)]
PX = [[int(x) for x in input().split()] for _ in range(Q)]
"""

X = int(input())
r = 0.01
s = 100

index = 1
while s <= 10 ** 18:
    s = int(s * (1 + r))
    if s >= X:
        break
    index += 1

print(index)

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

Solution (Python):

import sys
import math

X = int(input())
ans = 0
v = 100
while True:
    ans += 1
    v = v + math.floor(v * 0.01)
    if v >= X:
        print(ans)
        sys.exit()

Solution (Python):






"""Module docstring
"""

import functools
import heapq
import itertools
import logging
import math
import random
import string
import sys
from argparse import ArgumentParser
from collections import defaultdict, deque
from copy import deepcopy
from typing import Dict, List, Optional, Set, Tuple


def solve(target: int, deposit: int) -> int:
    value = deposit
    year = 0
    while value < target:
        value += value // 100
        year += 1
    return year


def do_job():
    "Do the work"
    LOG.debug("Start working")
    
    X = int(input())
    result = solve(X, 100)
    print(result)


def print_output(testcase: int, result) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case 
    
    


def configure_log() -> None:
    "Configure the log output"
    log_formatter = logging.Formatter("%(lineno)d - " "%(message)s")
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(log_formatter)
    LOG.addHandler(handler)


LOG = None

if not LOG:
    LOG = logging.getLogger("template")
    configure_log()


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    parser = ArgumentParser()
    parser.add_argument(
        "-v",
        "--verbose",
        dest="verbose",
        action="store_true",
        default=False,
        help="run as verbose mode",
    )
    args = parser.parse_args(argv)
    if args.verbose:
        LOG.setLevel(logging.DEBUG)
    do_job()
    return 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    sys.exit(main())


class memoized:
    """Decorator that caches a function's return value each time it is called.
    If called later with the same arguments, the cached value is returned, and
    not re-evaluated.
    """

    def __init__(self, func):
        self.func = func
        self.cache = {}

    def __call__(self, *args):
        try:
            return self.cache[args]
        except KeyError:
            value = self.func(*args)
            self.cache[args] = value
            return value
        except TypeError:
            
            
            return self.func(*args)

    def __repr__(self):
        """Return the function's docstring."""
        return self.func.__doc__

    def __get__(self, obj, objtype):
        """Support instance methods."""
        return functools.partial(self.__call__, obj)

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

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

Solution (Python):
import math

def resolve():
    X = int(input())
    keika = 0
    yokin = 100

    if X <= yokin:
        print(keika)
        return

    while True:
        yokin = math.floor(yokin * 1.01)
        keika += 1
        if X <= yokin:
            print(keika)
            return


if __name__ == "__main__":
    resolve()

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

Solution (Python):
import sys
import math


def main():
    input = sys.stdin.readline
    x = int(input())
    x = x

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

    print(years)


main()

Solution (Python):
import math
n = int(input())
i = 0
yokin = 100

while(yokin < n):
    yokin = int(yokin * 1.01)
    i += 1

print(i)

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

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

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

Solution (Python):
def main():
  X = int(input())
  K = 100
  count = 0
  
  while X > K :
    K = int(K * 1.01)
    count += 1
  
  print(count)

main()

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

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

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

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

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

year = 0
y = 100
t = True
while t:
    year += 1
    y = math.floor(y*1.01)
    if y >= x:
        print(year)
        t = False

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

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

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

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

print(count)

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

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

Solution (Python):
X = int(input())
a_pre = 100.0
for i in range(4000):
    a_new = a_pre*1.01
    if X <= a_new:
        print(i+1)
        exit()
    a_pre = int(a_new)

Solution (Python):
x = int(input())
n = 100
l = [100]
for i in range(5000):
    n += n * 0.01
    n = int(n)
    l.append(n)
for i in range(len(l)):
    if l[i] >= x:
        print(i)
        exit()

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

Solution (Python):
data = input()

x = int(data)


yen = 100.0
cnt = 0
while(1):
    cnt = cnt + 1
    yen = int(yen * 1.01)
    if yen >= x:
        print(cnt)
        break

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

while s < x:
    s = int(s * 1.01)
    t += 1

print(t)

Solution (Python):
X = int( input().strip() )  
p = 100 ;
for r in range ( 10000 ) :
	p= int ( p * 1.01 ) ;
	if p >= X :
		c = r + 1 ;
		break ;
print ( c ) ;

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

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

def main():
    mod=10**9+7
    X=I()
    N=100
    ans=0
    while N<X:
        N=int(N*1.01)
        ans+=1
    print(ans)

main()

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

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

Solution (Python):
X = input()

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

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

start = 100
r = 0.01
for i in range(1, 3761):
    start = start + start * r // 1
    if start >= x:
        print(i)
        exit()

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

now = 100
count = 0

while now < n:
  now = int(now*1.01)
  count += 1
  
print(count)

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

Solution (Python):
import math

X = int(input())

a = 100
cnt = 0

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

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

money = 100
year = 0

while True:
    if money >= x:
        break

    money = int(money * 1.01)
    year += 1

print(year)

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

a = 100

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

print(ans)

Solution (Python):
import sys
import math

X=int(input())
r=1.01

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

print(y)

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

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

print(ans)

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

Solution (Python):
x = int(input())
now = 100
for kek in range(123123):
	if(now >=x):
		print(kek)
		exit(0)
	now = (now* 101) //100

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

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

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

while yen < x:
  ans += 1
  yen = (yen * 101) // 100
  
print(ans)

Solution (Python):
import math

X = int(input())

p = 1.01
m = 100
y = 0

while m < X:
  m = math.floor(m * p)
  y += 1

print(y)

Solution (Python):
m=100
x=int(input(''))

s=0
while (1):
    if m>=x:
        break
    m=int(m*1.01)
    s=s+1

print(s)

Solution (Python):
import math

X=int(input())




i=0
t=100

while t < X:
  t = math.floor(t * 1.01)
  i += 1


print(i)

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

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

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

print(year)

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

Solution (Python):
X = int(input())
count = 0;
m = 100;
while(m < X):
    m = int(m + m * 0.01);
    count+=1
print(count)

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

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

Solution (Python):
X=int(input())
ans=100
for i in range(1,10000):
	ans+=int(ans*0.01)
	if ans>=X:
		print(i)
		exit()

Solution (Python):
import math
x=int(input())
k=100
s=0
while k<x:
    s+=1
    k=math.floor(k+k*1/100)
print(s)

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())
money = 100
year = 0
while money<X:
    money = int(money*1.01)
    year += 1
print(year)

Solution (Python):
x=int(input())
okane = 100
i = 0
while True:
    if x <= okane:
        print(i)
        exit()
    else:
        okane =int(okane)*1.01
        i += 1

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

Solution (Python):
X = int(input())
cnt = 0
yokin = 100
while (X > yokin):
    yokin = int(yokin * 1.01)
    cnt += 1

print(cnt)

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

    print(count)

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

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

a = 0
while Money < X: 
    Money *= 1.01
    Money = int(Money)
    a += 1
print(a)

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

print(i)

Solution (Python):
def calc(X):
    M = 100
    count = 0
    while True:
        if M >= X:
            return count
        M = M + int(M * 0.01)
        count = count + 1


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


if __name__ == '__main__':
    main()

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

dep = 100
year = 0
while dep < X:
    dep += int(0.01*dep)
    year += 1
    
print(year)

Solution (Python):

"""
@author: H_Hoshigi
"""
def main():
    X = int(input())
    a = 100
    counter = 0
    while a < X:
        a = (a * 1.01)//1
        counter += 1
    print(counter)

if __name__ == "__main__":
    main()

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

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

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

print(count)

Solution (Python):
import math

X = int(input())

yokin = 100
ans = 0

while(True):
  rishi = math.floor(yokin * 0.01)
  yokin += rishi
  ans += 1
  if yokin >= X:
    print(ans)
    break

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

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

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

Solution (Python):
from math import floor

def solve(x):
    y = 100
    years = 0
    while y < x:
        y = floor(y * 1.01)
        years += 1
    return years


if __name__ == "__main__":
    print(solve(int(input())))

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

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

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

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

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

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

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

Solution (Python):

import math
n = 0
X = int(input())
a = 100
while True:
    n += 1
    a = math.floor(a * 1.01)
    if a >= X:
        print(n)
        exit()

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

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

print(cnt)

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

keika_nen = 0
while True:
    keika_nen += 1
    mony = int(1.01 * mony)
    if mony >= X:
        break

print(keika_nen)

Solution (Python):
x = int(input())
now = 100
for kek in range(123123):
	if(now >=x):
		print(kek)
		exit(0)
	now = (now* 101) //100

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

Solution (Python):
import math

X = int(input())

first = 100
year = 0

while(X > first):
    year += 1
    first = math.floor(first * 1.01)
    
print(year)

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

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

print(c)

Solution (Python):
import sys,math
def input():
    return sys.stdin.readline()[:-1]
X = int(input())

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

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

s= 100

for i in range(10000000):
  s *= 1.01
  s = int(s)
  if s >= X:
    print(i+1)
    break

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

while k < n:
  k = int(k*1.01)
  count += 1
  
print(count)

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