





import random
import sys

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.colors import ListedColormap

__lowerCamelCase	:					Union[str, Any]			  =					"""Usage of script: script_name <size_of_canvas:int>"""

__lowerCamelCase	:					Any			  =					[0] * 100 + [1] * 10
random.shuffle(choice)



def 		A_    (					_lowerCAmelCase					)						->			list[list[bool]]:
 UpperCamelCase     : Optional[Any]	     =       [[False for i in range(_lowerCAmelCase					)] for j in range(_lowerCAmelCase					)]
 return canvas



def 		A_    (					_lowerCAmelCase					)						->			None:
 for i, row in enumerate(_lowerCAmelCase					):
  for j, _ in enumerate(_lowerCAmelCase					):
   UpperCamelCase     : int	     =       bool(random.getrandbits(1					)					)



def 		A_    (					_lowerCAmelCase					)						->			list[list[bool]]:
 UpperCamelCase     : List[Any]	     =       np.array(_lowerCAmelCase					)
 UpperCamelCase     : str	     =       np.array(create_canvas(current_canvas.shape[0]					)					)
 for r, row in enumerate(_lowerCAmelCase					):
  for c, pt in enumerate(_lowerCAmelCase					):
   UpperCamelCase     : Union[str, Any]	     =       __judge_point(
       _lowerCAmelCase							,       current_canvas[r - 1 : r + 2, c - 1 : c + 2]					)

 UpperCamelCase     : Tuple	     =       next_gen_canvas
 del next_gen_canvas  # cleaning memory as we move on.
 UpperCamelCase     : list[list[bool]]	     =       current_canvas.tolist()
 return return_canvas



def 		A_    (					_lowerCAmelCase							,       _lowerCAmelCase					)						->			bool:
 UpperCamelCase     : Optional[Any]	     =       0
 UpperCamelCase     : List[Any]	     =       0
 # finding dead or alive neighbours count.
 for i in neighbours:
  for status in i:
   if status:
    alive += 1
   else:
    dead += 1

    # handling duplicate entry for focus pt.
 if pt:
  alive -= 1
 else:
  dead -= 1

 # running the rules of game here.
 UpperCamelCase     : Union[str, Any]	     =       pt
 if pt:
  if alive < 2:
   UpperCamelCase     : Tuple	     =       False
  elif alive == 2 or alive == 3:
   UpperCamelCase     : int	     =       True
  elif alive > 3:
   UpperCamelCase     : Tuple	     =       False
 else:
  if alive == 3:
   UpperCamelCase     : Tuple	     =       True

 return state


if __name__ == "__main__":
    if len(sys.argv) != 2:
        raise Exception(usage_doc)

    __lowerCamelCase	:					Dict			  =					int(sys.argv[1])
    # main working structure of this module.
    __lowerCamelCase	:					Optional[Any]			  =					create_canvas(canvas_size)
    seed(c)
    __lowerCamelCase  ,     __lowerCamelCase	:					Any			  =					plt.subplots()
    fig.show()
    __lowerCamelCase	:					Dict			  =					ListedColormap(["""w""", """k"""])
    try:
        while True:
            __lowerCamelCase	:					Tuple			  =					run(c)
            ax.matshow(c, cmap=cmap)
            fig.canvas.draw()
            ax.cla()
    except KeyboardInterrupt:
        # do nothing.
        pass







def 		A_    (					_lowerCAmelCase					)						->			int:
 if n == 1 or not isinstance(_lowerCAmelCase							,       _lowerCAmelCase					):
  return 0
 elif n == 2:
  return 1
 else:
  UpperCamelCase     : Optional[Any]	     =       [0, 1]
  for i in range(2							,       n + 1					):
   sequence.append(sequence[i - 1] + sequence[i - 2]					)

  return sequence[n]



def 		A_    (					_lowerCAmelCase					)						->			int:
 UpperCamelCase     : Any	     =       0
 UpperCamelCase     : List[Any]	     =       2

 while digits < n:
  index += 1
  UpperCamelCase     : Union[str, Any]	     =       len(str(fibonacci(_lowerCAmelCase					)					)					)

 return index



def 		A_    (					_lowerCAmelCase = 1000					)						->			int:
 return fibonacci_digits_index(_lowerCAmelCase					)


if __name__ == "__main__":
    print(solution(int(str(input()).strip())))
