






'''simple docstring'''

from math import isclose, sqrt



def 				snake_case       (  a_				:			float     , a_				:			float     , a_				:			float						)							->					tuple[float, float, float]:





      """simple docstring"""

      UpperCamelCase_					: Optional[Any]            =				point_y / 4 / point_x
      UpperCamelCase_					: Optional[Any]            =				2 * normal_gradient / (1 + normal_gradient * normal_gradient)
      UpperCamelCase_					: Optional[int]            =				(1 - normal_gradient * normal_gradient) / (
          1 + normal_gradient * normal_gradient
      )
      UpperCamelCase_					: Tuple            =				(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

      # to find the next point, solve the simultaeneous equations:
      # y^2 + 4x^2 = 100
      # y - b = m * (x - a)
      # ==> A x^2 + B x + C = 0
      UpperCamelCase_					: Union[str, Any]            =				outgoing_gradient**2 + 4
      UpperCamelCase_					: Union[str, Any]            =				2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
      UpperCamelCase_					: str            =				(point_y - outgoing_gradient * point_x) ** 2 - 100

      UpperCamelCase_					: List[str]            =				(
          -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term						)
      ) / (2 * quadratic_term)
      UpperCamelCase_					: str            =				(
          -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term						)
      ) / (2 * quadratic_term)

      # two solutions, one of which is our input point
      UpperCamelCase_					: Tuple            =				x_minus if isclose(a_     , a_						) else x_plus
      UpperCamelCase_					: List[str]            =				point_y + outgoing_gradient * (next_x - point_x)

      return next_x, next_y, outgoing_gradient



def 				snake_case       (  a_				:			float = 1.4     , a_				:			float = -9.6						)							->					int:





      """simple docstring"""

      UpperCamelCase_					: int            =				0
      UpperCamelCase_					: float            =				first_x_coord
      UpperCamelCase_					: float            =				first_y_coord
      UpperCamelCase_					: float            =				(10.1 - point_y) / (0.0 - point_x)

      while not (-0.01 <= point_x <= 0.01 and point_y > 0):
            UpperCamelCase_     ,      UpperCamelCase_     ,      UpperCamelCase_					: List[Any]            =				next_point(a_     , a_     , a_						)
            num_reflections += 1

      return num_reflections


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














'''simple docstring'''

def 				snake_case       (  a_				:			int						)							->					int:





      """simple docstring"""

      if n == 1 or not isinstance(a_     , a_						):
            return 0
      elif n == 2:
            return 1
      else:
            UpperCamelCase_					: Dict            =				[0, 1]
            for i in range(2     , n + 1						):
                  sequence.append(sequence[i - 1] + sequence[i - 2]						)

            return sequence[n]



def 				snake_case       (  a_				:			int						)							->					int:





      """simple docstring"""

      UpperCamelCase_					: Any            =				0
      UpperCamelCase_					: Union[str, Any]            =				2

      while digits < n:
            index += 1
            UpperCamelCase_					: Any            =				len(str(fibonacci(a_						)						)						)

      return index



def 				snake_case       (  a_				:			int = 1_000						)							->					int:





      """simple docstring"""

      return fibonacci_digits_index(a_						)


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






