

'''simple docstring'''
from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
_lowerCamelCase	 =			TypeVar("""T""", bound="""Enum""")
@unique
class  _snake_case						(__SCREAMING_SNAKE_CASE):
			__A   :     Tuple          =80
			__A   :     str          =70
			__A   :     Dict          =60
			__A   :     List[str]          =50
			__A   :     Tuple          =40
			__A   :     Dict          =30
			__A   :     Dict          =20
			__A   :     int          =10




@unique
class  _snake_case						(__SCREAMING_SNAKE_CASE):
			__A   :     str          =24
			__A   :     Any          =21
			__A   :     str          =18
			__A   :     Optional[int]          =15
			__A   :     Tuple          =12
			__A   :     str          =9
			__A   :     List[Any]          =6
			__A   :     Dict          =3
			__A   :     List[Any]          =2
			__A   :     int          =1
			__A   :     Any          =-1
			__A   :     Union[str, Any]          =-2
			__A   :     Union[str, Any]          =-3
			__A   :     Optional[Any]          =-6
			__A   :     str          =-9
			__A   :     Optional[int]          =-12
			__A   :     Dict          =-15
			__A   :     Any          =-18
			__A   :     Optional[Any]          =-21
			__A   :     int          =-24






			@classmethod
			def 						UpperCamelCase__				(   cls			):
				return {unit.name: unit.value for unit in cls if unit.value > 0}






			@classmethod
			def 						UpperCamelCase__				(   cls			):
				return {unit.name: unit.value for unit in cls if unit.value < 0}




def       a__    (  _SCREAMING_SNAKE_CASE					:    float							)			-> str:


	"""simple docstring"""





	UpperCAmelCase_			:	int      =   SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
	for name_prefix, value_prefix in prefixes.items():
		UpperCAmelCase_			:	List[str]      =   value / (10**value_prefix)
		if numerical_part > 1:
			return F'''{numerical_part!s} {name_prefix}'''
	return str(_SCREAMING_SNAKE_CASE							)


def       a__    (  _SCREAMING_SNAKE_CASE					:    float							)			-> str:


	"""simple docstring"""





	for prefix in BinaryUnit:
		UpperCAmelCase_			:	List[str]      =   value / (2**prefix.value)
		if numerical_part > 1:
			return F'''{numerical_part!s} {prefix.name}'''
	return str(_SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
					import doctest

					doctest.testmod()







'''simple docstring'''
def       a__    (  _SCREAMING_SNAKE_CASE					:    list     ,							_SCREAMING_SNAKE_CASE					:    int							)			-> int:


	"""simple docstring"""





	for index, item in enumerate(_SCREAMING_SNAKE_CASE							):
		if item == target:
			return index
	return -1


def       a__    (  _SCREAMING_SNAKE_CASE					:    list     ,							_SCREAMING_SNAKE_CASE					:    int     ,							_SCREAMING_SNAKE_CASE					:    int     ,							_SCREAMING_SNAKE_CASE					:    int							)			-> int:


	"""simple docstring"""





	if not (0 <= high < len(_SCREAMING_SNAKE_CASE							) and 0 <= low < len(_SCREAMING_SNAKE_CASE							)):
		raise Exception("Invalid upper or lower bound!"							)
	if high < low:
		return -1
	if sequence[low] == target:
		return low
	if sequence[high] == target:
		return high
	return rec_linear_search(_SCREAMING_SNAKE_CASE     ,							low + 1     ,							high - 1     ,							_SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
					_lowerCamelCase	 =			input("""Enter numbers separated by comma:\n""").strip()
					_lowerCamelCase	 =			[int(item.strip()) for item in user_input.split(""",""")]

					_lowerCamelCase	 =			int(input("""Enter a single number to be found in the list:\n""").strip())
					_lowerCamelCase	 =			linear_search(sequence, target)
					if result != -1:
										print(f"""linear_search({sequence}, {target}) = {result}""")
					else:
										print(f"""{target} was not found in {sequence}""")




