





"""simple docstring"""



def 		__lowercase     (   snake_case_  :  List[str]				,snake_case_  :  int						)   ->Optional[int]:



    '''simple docstring'''







    return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2







def 		__lowercase     (   snake_case_  :  int				,snake_case_  :  Optional[Any]=0						)   ->Optional[Any]:



    '''simple docstring'''







    return sorted(snake_case_				,key=lambda snake_case_						: x[column]						)







def 		__lowercase     (   snake_case_  :  Optional[Any]				,snake_case_  :  str				,snake_case_  :  Optional[int]=float('''inf'''						)						)   ->str:



    '''simple docstring'''







    for i in range(points_counts - 1						):
        for j in range(i + 1				,snake_case_						):
            __A    :						str						 =     euclidean_distance_sqr(points[i]				,points[j]						)
            if current_dis < min_dis:
                __A    :						Union[str, Any]						 =     current_dis
    return min_dis







def 		__lowercase     (   snake_case_  :  List[str]				,snake_case_  :  Optional[int]				,snake_case_  :  int=float('''inf'''						)						)   ->Any:



    '''simple docstring'''







    for i in range(min(6				,points_counts - 1						)				,snake_case_						):
        for j in range(max(0				,i - 6						)				,snake_case_						):
            __A    :						Optional[int]						 =     euclidean_distance_sqr(points[i]				,points[j]						)
            if current_dis < min_dis:
                __A    :						Optional[Any]						 =     current_dis
    return min_dis







def 		__lowercase     (   snake_case_  :  Union[str, Any]				,snake_case_  :  Any				,snake_case_  :  int						)   ->Optional[Any]:



    '''simple docstring'''







    if points_counts <= 3:
        return dis_between_closest_pair(snake_case_				,snake_case_						)

    # recursion
    __A    :						Dict						 =     points_counts // 2
    __A    :						str						 =     closest_pair_of_points_sqr(
        snake_case_				,points_sorted_on_y[:mid]				,snake_case_						)
    __A    :						Optional[Any]						 =     closest_pair_of_points_sqr(
        snake_case_				,points_sorted_on_y[mid:]				,points_counts - mid						)
    __A    :						Tuple						 =     min(snake_case_				,snake_case_						)
    __A    :						str						 =     []
    for point in points_sorted_on_x:
        if abs(point[0] - points_sorted_on_x[mid][0]						) < closest_pair_dis:
            cross_strip.append(snake_case_						)

    __A    :						str						 =     dis_between_closest_in_strip(
        snake_case_				,len(snake_case_						)				,snake_case_						)
    return min(snake_case_				,snake_case_						)







def 		__lowercase     (   snake_case_  :  Any				,snake_case_  :  Dict						)   ->List[Any]:



    '''simple docstring'''







    __A    :						List[Any]						 =     column_based_sort(snake_case_				,column=0						)
    __A    :						Union[str, Any]						 =     column_based_sort(snake_case_				,column=1						)
    return (
        closest_pair_of_points_sqr(
            snake_case_				,snake_case_				,snake_case_						)
    ) ** 0.5


if __name__ == "__main__":
       a_ =			[(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
       print("""Distance:""", closest_pair_of_points(points, len(points)))








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


