


from math import ceil




def    snake_case_     (  snake_case			,							snake_case     )  ->				Optional[Any]:
       lowercase__:   Optional[int]  			=   list(range(0			,							snake_case     )     )

       lowercase__:   Optional[Any]  			=   [item for sublist in list(device_map.values()     ) for item in sublist]

       # Duplicate check
       lowercase__:   Union[str, Any]  			=   []
       for i in device_map_blocks:
              if device_map_blocks.count(snake_case     ) > 1 and i not in duplicate_blocks:
                     duplicate_blocks.append(snake_case     )
    # Missing blocks
       lowercase__:   int  			=   [i for i in blocks if i not in device_map_blocks]
       lowercase__:   Optional[Any]  			=   [i for i in device_map_blocks if i not in blocks]

       if len(snake_case     ) != 0:
              raise ValueError(
                  'Duplicate attention blocks specified in device_map. Attention blocks must be specified to one device.'
                  ' These attention blocks were specified more than once: ' + str(snake_case     )     )
       if len(snake_case     ) != 0:
              raise ValueError(
                  'There are attention blocks for this model that are not specified in the device_map. Add these attention '
                  'blocks to a device on the device_map: ' + str(snake_case     )     )
       if len(snake_case     ) != 0:
              raise ValueError(
                  'The device_map contains more attention blocks than this model has. Remove these from the device_map:'
                  + str(snake_case     )     )




def    snake_case_     (  snake_case			,							snake_case     )  ->				Tuple:
       lowercase__:   int  			=   list(range(snake_case     )     )
       lowercase__:   Any  			=   int(ceil(n_layers / len(snake_case     )     )     )
       lowercase__:   Any  			=   [layers[i : i + n_blocks] for i in range(0			,							snake_case			,							snake_case     )]

       return dict(zip(snake_case			,							snake_case     )     )






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


