from __future__ import annotations

import bisect






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				List[Any]		, _SCREAMING_SNAKE_CASE     :				Optional[Any]		, _SCREAMING_SNAKE_CASE     :				Tuple = 0		, _SCREAMING_SNAKE_CASE     :				Union[str, Any] = -1			):


						if hi < 0:
												UpperCamelCase_		:							Optional[Any]  =		len(_A			)

						while lo < hi:
												UpperCamelCase_		:							Tuple  =		lo + (hi - lo) // 2
												if sorted_collection[mid] < item:
																		UpperCamelCase_		:							Optional[Any]  =		mid + 1
												else:
																		UpperCamelCase_		:							Union[str, Any]  =		mid

						return lo






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Dict		, _SCREAMING_SNAKE_CASE     :				str		, _SCREAMING_SNAKE_CASE     :				Any = 0		, _SCREAMING_SNAKE_CASE     :				str = -1			):


						if hi < 0:
												UpperCamelCase_		:							Optional[int]  =		len(_A			)

						while lo < hi:
												UpperCamelCase_		:							Any  =		lo + (hi - lo) // 2
												if sorted_collection[mid] <= item:
																		UpperCamelCase_		:							Union[str, Any]  =		mid + 1
												else:
																		UpperCamelCase_		:							Optional[Any]  =		mid

						return lo






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Tuple		, _SCREAMING_SNAKE_CASE     :				int		, _SCREAMING_SNAKE_CASE     :				Optional[int] = 0		, _SCREAMING_SNAKE_CASE     :				Any = -1			):
						sorted_collection.insert(bisect_left(_A		, _A		, _A		, _A			)		, _A			)






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				List[str]		, _SCREAMING_SNAKE_CASE     :				str		, _SCREAMING_SNAKE_CASE     :				Optional[int] = 0		, _SCREAMING_SNAKE_CASE     :				Tuple = -1			):
						sorted_collection.insert(bisect_right(_A		, _A		, _A		, _A			)		, _A			)






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Union[str, Any]		, _SCREAMING_SNAKE_CASE     :				str			):
						UpperCamelCase_		:							Tuple  =		0
						UpperCamelCase_		:							Dict  =		len(_A			) - 1

						while left <= right:
												UpperCamelCase_		:							Optional[int]  =		left + (right - left) // 2
												UpperCamelCase_		:							List[str]  =		sorted_collection[midpoint]
												if current_item == item:
																		return midpoint
												elif item < current_item:
																		UpperCamelCase_		:							Union[str, Any]  =		midpoint - 1
												else:
																		UpperCamelCase_		:							Tuple  =		midpoint + 1
						return None






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Optional[int]		, _SCREAMING_SNAKE_CASE     :				Dict			):
						UpperCamelCase_		:							Union[str, Any]  =		bisect.bisect_left(_A		, _A			)
						if index != len(_A			) and sorted_collection[index] == item:
												return index
						return None






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				List[str]		, _SCREAMING_SNAKE_CASE     :				List[Any]		, _SCREAMING_SNAKE_CASE     :				Optional[int]		, _SCREAMING_SNAKE_CASE     :				Dict			):


						if right < left:
												return None

						UpperCamelCase_		:							Tuple  =		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__":
	SCREAMING_SNAKE_CASE		:     List[Any]         =	input("Enter numbers separated by comma:\n").strip()
	SCREAMING_SNAKE_CASE		:     List[Any]         =	sorted(int(item) for item in user_input.split(","))
	SCREAMING_SNAKE_CASE		:     Tuple         =	int(input("Enter a single number to be found in the list:\n"))
	SCREAMING_SNAKE_CASE		:     Any         =	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}.''')







from typing import Any



def 	__A		(      _A       ):



 """simple docstring"""


 if not input_list:
  return []
 __a							=	[input_list.count(_A       ) for value in input_list]
 __a							=	max(_A       )  # Gets the maximum count in the input list.
 # Gets values of modes
 return sorted({input_list[i] for i, value in enumerate(_A       ) if value == y}       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()


