



from math import isqrt, loga
def 						UpperCamelCase      (  snake_case__			:       Dict      )      ->	list[int]:
   UpperCamelCase       :    Tuple		      =      [True] * max_number
   for i in range(2			,	isqrt(max_number - 1      ) + 1      ):
      if is_prime[i]:
         for j in range(i**2			,	__SCREAMING_SNAKE_CASE			,	__SCREAMING_SNAKE_CASE      ):
            UpperCamelCase       :    List[str]		      =      False

   return [i for i in range(2			,	__SCREAMING_SNAKE_CASE      ) if is_prime[i]]
def 						UpperCamelCase      (  snake_case__			:       List[str] = 800800			,	snake_case__			:       Optional[int] = 800800      )      ->	int:
   UpperCamelCase       :    Tuple		      =      degree * loga(__SCREAMING_SNAKE_CASE      )
   UpperCamelCase       :    Dict		      =      int(__SCREAMING_SNAKE_CASE      )
   UpperCamelCase       :    Union[str, Any]		      =      calculate_prime_numbers(__SCREAMING_SNAKE_CASE      )

   UpperCamelCase       :    Union[str, Any]		      =      0
   UpperCamelCase       :    Tuple		      =      0
   UpperCamelCase       :    Optional[int]		      =      len(__SCREAMING_SNAKE_CASE      ) - 1
   while left < right:
      while (
          prime_numbers[right] * loga(prime_numbers[left]      )
          + prime_numbers[left] * loga(prime_numbers[right]      )
          > upper_bound
      ):
         right -= 1
      hybrid_integers_count += right - left
      left += 1

   return hybrid_integers_count


if __name__ == "__main__":
    print(F"""{solution() = }""")









'''simple docstring'''






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   int:
      if n == 1 or not isinstance(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		):
            return 0
      elif n == 2:
            return 1
      else:
            snake_case__       :   int	      =    [0, 1]
            for i in range(2				,      n + 1		):
                  sequence.append(sequence[i - 1] + sequence[i - 2]		)

            return sequence[n]






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   int:
      snake_case__       :   Optional[int]	      =    0
      snake_case__       :   Dict	      =    2

      while digits < n:
            index += 1
            snake_case__       :   Optional[int]	      =    len(str(fibonacci(__SCREAMING_SNAKE_CASE		)		)		)

      return index






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE = 1000		)    ->   int:
      return fibonacci_digits_index(__SCREAMING_SNAKE_CASE		)


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