
from __future__ import annotations

import bisect

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int							,						__UpperCamelCase :						int = 0							,						__UpperCamelCase :						int = -1       ) ->       int:

				"""simple docstring"""







				if hi < 0:
								A__  :	Union[str, Any]         =							len(__UpperCamelCase       )

				while lo < hi:
								A__  :	str         =							lo + (hi - lo) // 2
								if sorted_collection[mid] < item:
												A__  :	List[Any]         =							mid + 1
								else:
												A__  :	Optional[int]         =							mid

				return lo

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int							,						__UpperCamelCase :						int = 0							,						__UpperCamelCase :						int = -1       ) ->       int:

				"""simple docstring"""







				if hi < 0:
								A__  :	Dict         =							len(__UpperCamelCase       )

				while lo < hi:
								A__  :	int         =							lo + (hi - lo) // 2
								if sorted_collection[mid] <= item:
												A__  :	Dict         =							mid + 1
								else:
												A__  :	int         =							mid

				return lo

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int							,						__UpperCamelCase :						int = 0							,						__UpperCamelCase :						int = -1       ) ->       None:

				"""simple docstring"""







				sorted_collection.insert(bisect_left(__UpperCamelCase							,						__UpperCamelCase							,						__UpperCamelCase							,						__UpperCamelCase       )							,						__UpperCamelCase       )

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int							,						__UpperCamelCase :						int = 0							,						__UpperCamelCase :						int = -1       ) ->       None:

				"""simple docstring"""







				sorted_collection.insert(bisect_right(__UpperCamelCase							,						__UpperCamelCase							,						__UpperCamelCase							,						__UpperCamelCase       )							,						__UpperCamelCase       )

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int       ) ->       int | None:

				"""simple docstring"""







				A__  :	List[Any]         =							0
				A__  :	Union[str, Any]         =							len(__UpperCamelCase       ) - 1

				while left <= right:
								A__  :	Dict         =							left + (right - left) // 2
								A__  :	Optional[Any]         =							sorted_collection[midpoint]
								if current_item == item:
												return midpoint
								elif item < current_item:
												A__  :	Optional[Any]         =							midpoint - 1
								else:
												A__  :	str         =							midpoint + 1
				return None

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int       ) ->       int | None:

				"""simple docstring"""







				A__  :	Dict         =							bisect.bisect_left(__UpperCamelCase							,						__UpperCamelCase       )
				if index != len(__UpperCamelCase       ) and sorted_collection[index] == item:
								return index
				return None

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						list[int]							,						__UpperCamelCase :						int							,						__UpperCamelCase :						int							,						__UpperCamelCase :						int       ) ->       int | None:

				"""simple docstring"""







				if right < left:
								return None

				A__  :	Tuple         =							left + (right - left) // 2

				if sorted_collection[midpoint] == item:
								return midpoint
				elif sorted_collection[midpoint] > item:
								return binary_search_by_recursion(__UpperCamelCase							,						__UpperCamelCase							,						__UpperCamelCase							,						midpoint - 1       )
				else:
								return binary_search_by_recursion(__UpperCamelCase							,						__UpperCamelCase							,						midpoint + 1							,						__UpperCamelCase       )


if __name__ == "__main__":
					_SCREAMING_SNAKE_CASE    :      Dict          =			input('Enter numbers separated by comma:\n').strip()
					_SCREAMING_SNAKE_CASE    :      Union[str, Any]          =			sorted(int(item) for item in user_input.split(','))
					_SCREAMING_SNAKE_CASE    :      List[Any]          =			int(input('Enter a single number to be found in the list:\n'))
					_SCREAMING_SNAKE_CASE    :      Tuple          =			binary_search(collection, target)
					if result is None:
										print(f"""{target} was not found in {collection}.""")
					else:
										print(f"""{target} was found at position {result} in {collection}.""")

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						int       ) ->       int:

				"""simple docstring"""







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

								return sequence[n]

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						int       ) ->       int:

				"""simple docstring"""







				A__  :	Dict         =							0
				A__  :	Optional[int]         =							2

				while digits < n:
								index += 1
								A__  :	Dict         =							len(str(fibonacci(__UpperCamelCase       )       )       )

				return index

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						int = 10_00       ) ->       int:

				"""simple docstring"""







				return fibonacci_digits_index(__UpperCamelCase       )


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