

def _a			(	SCREAMING_SNAKE_CASE		:      Union[str, Any]   , SCREAMING_SNAKE_CASE		:      Optional[int]		)   ->   Optional[Any]:

 """simple docstring"""






 sequence.append(SCREAMING_SNAKE_CASE		)

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

 sequence.pop()

 if index == len(SCREAMING_SNAKE_CASE		):
  return None

 return index


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

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








import torch

from transformers import PreTrainedModel

from .custom_configuration import CustomConfig, NoSuperInitConfig






class 							A_			(		snake_case__ ):
     _lowercase      :					Any       =     CustomConfig


     def __init__(							self      :		List[Any]      ,  UpperCAmelCase      :		Optional[Any] )							->     int:
      super().__init__(UpperCAmelCase )
      __lowerCAmelCase:       Tuple            =				torch.nn.Linear(config.hidden_size      ,  config.hidden_size )


     def   UpperCAmelCase  (							self      :		Optional[int]      ,  UpperCAmelCase      :		Tuple )							->     Union[str, Any]:
      return self.linear(UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		str )							->     Optional[int]:
      pass







class 							A_			(		snake_case__ ):
     _lowercase      :					str       =     NoSuperInitConfig


     def __init__(							self      :		List[Any]      ,  UpperCAmelCase      :		Union[str, Any] )							->     int:
      super().__init__(UpperCAmelCase )
      __lowerCAmelCase:       int            =				torch.nn.Linear(config.attribute      ,  config.attribute )


     def   UpperCAmelCase  (							self      :		Tuple      ,  UpperCAmelCase      :		Tuple )							->     Tuple:
      return self.linear(UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		Optional[Any]      ,  UpperCAmelCase      :		Any )							->     str:
      pass





