






from __future__ import annotations

import bisect







def       lowercase__	(					A_:						list[int]  ,      A_:						int  ,      A_:						int = 0  ,      A_:						int = -1		)	->				int:







       """simple docstring"""






       if hi < 0:
              __UpperCAmelCase     				=len(A_		)

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

       return lo







def       lowercase__	(					A_:						list[int]  ,      A_:						int  ,      A_:						int = 0  ,      A_:						int = -1		)	->				int:







       """simple docstring"""






       if hi < 0:
              __UpperCAmelCase     				=len(A_		)

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

       return lo







def       lowercase__	(					A_:						list[int]  ,      A_:						int  ,      A_:						int = 0  ,      A_:						int = -1		)	->				None:







       """simple docstring"""






       sorted_collection.insert(bisect_left(A_  ,      A_  ,      A_  ,      A_		)  ,      A_		)







def       lowercase__	(					A_:						list[int]  ,      A_:						int  ,      A_:						int = 0  ,      A_:						int = -1		)	->				None:







       """simple docstring"""






       sorted_collection.insert(bisect_right(A_  ,      A_  ,      A_  ,      A_		)  ,      A_		)







def       lowercase__	(					A_:						list[int]  ,      A_:						int		)	->				int | None:







       """simple docstring"""






       __UpperCAmelCase     				=0
       __UpperCAmelCase     				=len(A_		) - 1

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







def       lowercase__	(					A_:						list[int]  ,      A_:						int		)	->				int | None:







       """simple docstring"""






       __UpperCAmelCase     				=bisect.bisect_left(A_  ,      A_		)
       if index != len(A_		) and sorted_collection[index] == item:
              return index
       return None







def       lowercase__	(					A_:						list[int]  ,      A_:						int  ,      A_:						int  ,      A_:						int		)	->				int | None:







       """simple docstring"""






       if right < left:
              return None

       __UpperCAmelCase     				=left + (right - left) // 2

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


if __name__ == "__main__":
   __A					=	input("Enter numbers separated by comma:\n").strip()
   __A					=	sorted(int(item) for item in user_input.split(","))
   __A					=	int(input("Enter a single number to be found in the list:\n"))
   __A					=	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}.""")








'''simple docstring'''






def    _snake_case  (	A			)		->       int:
							if n == 1 or not isinstance(A					,       A			):
														return 0
							elif n == 2:
														return 1
							else:
														lowerCAmelCase__			  =      [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:
							lowerCAmelCase__			  =      0
							lowerCAmelCase__			  =      2

							while digits < n:
														index += 1
														lowerCAmelCase__			  =      len(str(fibonacci(A			)			)			)

							return index


def    _snake_case  (	A = 1000			)		->       int:
							return fibonacci_digits_index(A			)


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