


from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass





@dataclass
class   __a			:
 __lowercase :							int
 __lowercase :							int





class   __a			:
 def __init__(   self				, lowerCAmelCase__ )					->				List[str]:




        '''simple docstring'''
        lowercase__:   list[list[Edge]]  			=   [[] for _ in range(lowerCAmelCase__ )]
        lowercase__:   Union[str, Any]  			=   size
 def __getitem__(   self				, lowerCAmelCase__ )					->				Iterator[Edge]:




        '''simple docstring'''
        return iter(self._graph[vertex] )
 @property
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Union[str, Any]:




        '''simple docstring'''
        return self._size
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__				, lowerCAmelCase__ )					->				Any:




        '''simple docstring'''
        if weight not in (0, 1):
               raise ValueError('Edge weight must be either 0 or 1.' )

        if to_vertex < 0 or to_vertex >= self.size:
               raise ValueError('Vertex indexes must be in [0; size).' )

        self._graph[from_vertex].append(Edge(lowerCAmelCase__				, lowerCAmelCase__ ) )
 def 		SCREAMING_SNAKE_CASE__   (   self				, lowerCAmelCase__				, lowerCAmelCase__ )					->				int | None:




        '''simple docstring'''
        lowercase__:   List[str]  			=   deque([start_vertex] )
        lowercase__:   list[int | None]  			=   [None] * self.size
        lowercase__:   List[str]  			=   0

        while queue:
               lowercase__:   List[str]  			=   queue.popleft()
               lowercase__:   str  			=   distances[current_vertex]
               if current_distance is None:
                      continue

               for edge in self[current_vertex]:
                      lowercase__:   List[Any]  			=   current_distance + edge.weight
                      lowercase__:   List[str]  			=   distances[edge.destination_vertex]
                      if (
                          isinstance(lowerCAmelCase__				, lowerCAmelCase__ )
                          and new_distance >= dest_vertex_distance
                      ):
                             continue
                      lowercase__:   Optional[int]  			=   new_distance
                      if edge.weight == 0:
                             queue.appendleft(edge.destination_vertex )
                      else:
                             queue.append(edge.destination_vertex )

        if distances[finish_vertex] is None:
               raise ValueError('No path from start_vertex to finish_vertex.' )

        return distances[finish_vertex]


if __name__ == "__main__":
 import doctest

 doctest.testmod()






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

              return sequence[n]




def    snake_case_     (  snake_case     )  ->				int:
       lowercase__:   int  			=   0
       lowercase__:   int  			=   2

       while digits < n:
              index += 1
              lowercase__:   Tuple  			=   len(str(fibonacci(snake_case     )     )     )

       return index




def    snake_case_     (  snake_case = 10_00     )  ->				int:
       return fibonacci_digits_index(snake_case     )


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


