





'''simple docstring'''
from ..utils import DummyObject, requires_backends

class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[str]      		=["tokenizers"]






 def __init__(	self	:							Tuple							,     *__A	:							int							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Optional[Any]							,     *__A	:							Optional[Any]							,     **__A	:							str     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Tuple							,     *__A	:							int							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : int      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Optional[int]							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							Any							,     *__A	:							Any							,     **__A	:							Union[str, Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							List[Any]							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Union[str, Any]							,     **__A	:							Optional[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Optional[Any]							,     *__A	:							Any							,     **__A	:							Union[str, Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							Tuple							,     *__A	:							List[str]							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							int							,     **__A	:							int     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Dict							,     *__A	:							Tuple							,     **__A	:							int     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : int      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							Any							,     **__A	:							Dict     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							str							,     *__A	:							Dict							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[str]      		=["tokenizers"]






 def __init__(	self	:							int							,     *__A	:							List[str]							,     **__A	:							List[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							Union[str, Any]							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Union[str, Any]      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Optional[int]							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							List[str]							,     *__A	:							List[str]							,     **__A	:							Optional[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							str							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : str      		=["tokenizers"]






 def __init__(	self	:							str							,     *__A	:							Optional[int]							,     **__A	:							int     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[str]      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							Optional[Any]							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Dict      		=["tokenizers"]






 def __init__(	self	:							str							,     *__A	:							Dict							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : int      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Dict							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[Any]      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							Dict							,     **__A	:							str     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Dict							,     *__A	:							Union[str, Any]							,     **__A	:							List[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Tuple							,     *__A	:							Optional[int]							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Optional[Any]							,     **__A	:							List[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							int							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[str]      		=["tokenizers"]






 def __init__(	self	:							Optional[Any]							,     *__A	:							Union[str, Any]							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Dict      		=["tokenizers"]






 def __init__(	self	:							List[str]							,     *__A	:							Optional[Any]							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							List[str]							,     *__A	:							Optional[Any]							,     **__A	:							Optional[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							List[str]							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[Any]      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							List[str]							,     **__A	:							Optional[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							Dict							,     *__A	:							Dict							,     **__A	:							str     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							Optional[int]							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[Any]      		=["tokenizers"]






 def __init__(	self	:							int							,     *__A	:							str							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							Optional[Any]							,     *__A	:							Any							,     **__A	:							int     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Any							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Union[str, Any]      		=["tokenizers"]






 def __init__(	self	:							Any							,     *__A	:							Tuple							,     **__A	:							Optional[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							int							,     *__A	:							List[str]							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							int							,     **__A	:							Optional[int]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Union[str, Any]      		=["tokenizers"]






 def __init__(	self	:							Dict							,     *__A	:							Union[str, Any]							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Any							,     *__A	:							List[str]							,     **__A	:							Union[str, Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[Any]      		=["tokenizers"]






 def __init__(	self	:							Any							,     *__A	:							Dict							,     **__A	:							List[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : str      		=["tokenizers"]






 def __init__(	self	:							Any							,     *__A	:							Optional[int]							,     **__A	:							str     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[Any]      		=["tokenizers"]






 def __init__(	self	:							List[Any]							,     *__A	:							List[Any]							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Union[str, Any]							,     *__A	:							Any							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : int      		=["tokenizers"]






 def __init__(	self	:							Dict							,     *__A	:							List[Any]							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : str      		=["tokenizers"]






 def __init__(	self	:							Tuple							,     *__A	:							Tuple							,     **__A	:							int     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[str]      		=["tokenizers"]






 def __init__(	self	:							List[str]							,     *__A	:							Optional[Any]							,     **__A	:							str     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : str      		=["tokenizers"]






 def __init__(	self	:							int							,     *__A	:							Tuple							,     **__A	:							List[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Tuple      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							Optional[Any]							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : List[str]      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							int							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : int      		=["tokenizers"]






 def __init__(	self	:							Dict							,     *__A	:							Any							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							str							,     *__A	:							Tuple							,     **__A	:							Tuple     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : str      		=["tokenizers"]






 def __init__(	self	:							Optional[Any]							,     *__A	:							int							,     **__A	:							Optional[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Dict      		=["tokenizers"]






 def __init__(	self	:							List[str]							,     *__A	:							Optional[int]							,     **__A	:							List[Any]     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Any      		=["tokenizers"]






 def __init__(	self	:							Optional[int]							,     *__A	:							List[str]							,     **__A	:							Any     ):
        requires_backends(self							,     ['tokenizers']     )






class 					snake_case					(   metaclass=__lowerCamelCase	):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_     : Optional[int]      		=["tokenizers"]






 def __init__(	self	:							Optional[Any]							,     *__A	:							Optional[int]							,     **__A	:							List[str]     ):
        requires_backends(self							,     ['tokenizers']     )







'''simple docstring'''
def     lowercase__       (       __lowercase						:  str    ,  __lowercase						:  Tuple					)			->				str:



       """simple docstring"""






       sequence.append(__lowercase					)

       __UpperCamelCase	=  0
       while sequence[index] != target:
              index += 1

       sequence.pop()

       if index == len(__lowercase					):
              return None

       return index


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

    a__							:							Tuple			=input('''Enter a single number to be found in the list:\n''')
    a__							:							List[Any]			=int(target_input)
    a__							:							List[Any]			=sentinel_linear_search(sequence, target)
    if result is not None:
        print(f'{target} found at positions: {result}')
    else:
        print('''Not found''')
