code: 
  
  
  
  
  
  
  """simple docstring"""
  import os
  import tempfile
  import unittest
  from typing import List
  
  from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
  from transformers.testing_utils import require_tokenizers
  from transformers.tokenization_utils import PreTrainedTokenizer
  from transformers.tokenization_utils_base import PreTrainedTokenizerBase
  
  
  
  @require_tokenizers
  class 					UpperCamelCase__   (							unittest.TestCase):
  
  
  
  
  
  
  
  				"""simple docstring"""
  				__UpperCAmelCase											=   EsmTokenizer
  
  
  
  
  
  
  
  				def 							a__ (		self   :  str   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											super().setUp()
  											__magic_name__										=						tempfile.mkdtemp()
  											# fmt: off
  											__magic_name__										=						['<cls>', '<pad>', '<eos>', '<unk>', 'L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C', 'X', 'B', 'U', 'Z', 'O', '.', '-', '<null_1>', '<mask>']  # noqa: E501
  											# fmt: on
  											__magic_name__										=						os.path.join(self.tmpdirname							,						VOCAB_FILES_NAMES['vocab_file']   )
  											with open(self.vocab_file							,						'w'							,						encoding='utf-8'   ) as vocab_writer:
  																		vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )
  
  
  
  
  
  
  
  				def 							a__ (		self   :  Dict							,						**UpperCamelCase_   :  Union[str, Any]   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											return [self.get_tokenizer(**UpperCamelCase_   )]
  
  
  
  
  
  
  
  				def 							a__ (		self   :  int							,						**UpperCamelCase_   :  Any   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											return self.tokenizer_class.from_pretrained(self.tmpdirname							,						**UpperCamelCase_   )
  
  
  
  
  
  
  
  				def 							a__ (		self   :  Optional[Any]   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											__magic_name__										=						self.tokenizer_class(self.vocab_file   )
  
  											__magic_name__										=						tokenizer.tokenize('LAGVS'   )
  											self.assertListEqual(UpperCamelCase_							,						['L', 'A', 'G', 'V', 'S']   )
  											self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase_   )							,						[4, 5, 6, 7, 8]   )
  
  
  
  
  
  
  
  				def 							a__ (		self   :  Any   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											__magic_name__										=						self.tokenizer_class(self.vocab_file   )
  
  											__magic_name__										=						'LAGVS'
  											self.assertListEqual(tokenizer.encode(UpperCamelCase_   )							,						[0, 4, 5, 6, 7, 8, 2]   )
  
  
  
  
  
  
  
  				def 							a__ (		self   :  Tuple   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											__magic_name__										=						self.tokenizer_class(self.vocab_file   )
  
  											__magic_name__										=						['LAGVS', 'WCB']
  											__magic_name__										=						tokenizer(UpperCamelCase_							,						padding=UpperCamelCase_   )['input_ids']
  
  											self.assertListEqual(UpperCamelCase_							,						[[0, 4, 5, 6, 7, 8, 2], [0, 2_2, 2_3, 2_5, 2]]   )
  
  
  
  
  
  
  
  				def 							a__ (		self   :  Optional[int]   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											__magic_name__										=						self.tokenizer_class(self.vocab_file   )
  
  											__magic_name__										=						['LAGVS', 'WCB']
  											__magic_name__										=						tokenizer(UpperCamelCase_							,						padding=UpperCamelCase_   )['input_ids']
  
  											self.assertListEqual(UpperCamelCase_							,						[[0, 4, 5, 6, 7, 8, 2], [0, 2_2, 2_3, 2_5, 2, 1, 1]]   )
  
  
  
  
  
  
  
  				def 							a__ (		self   :  Dict   ):
  
  
  
  
  
  											'''simple docstring'''
  
  											__magic_name__										=						self.get_tokenizers(fast=UpperCamelCase_   )
  											for tokenizer in tokenizers:
  																		with self.subTest(f"""{tokenizer.__class__.__name__}"""   ):
  																									__magic_name__										=						'<unk>'
  																									__magic_name__										=						'<mask>'
  
  																									__magic_name__										=						tokenizer.tokenize(UpperCamelCase_   )
  																									__magic_name__										=						tokenizer.tokenize(UpperCamelCase_   )
  
  																									self.assertEqual(len(UpperCamelCase_   )							,						1   )
  																									self.assertEqual(len(UpperCamelCase_   )							,						1   )
  																									self.assertEqual(token_a[0]							,						UpperCamelCase_   )
  																									self.assertEqual(token_a[0]							,						UpperCamelCase_   )
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  def        A	(							__snake_case:   Dict   ,    __snake_case:   Tuple     )						->		int:
  
         """simple docstring"""
  
  
  
  
  
         sequence.append(__snake_case     )
  
         __magic_name__										=						0
         while sequence[index] != target:
                index += 1
  
         sequence.pop()
  
         if index == len(__snake_case     ):
                return None
  
         return index
  
  
  if __name__ == "__main__":
   snake_case   :   Dict    		=		input("""Enter numbers separated by comma:\n""").strip()
   snake_case   :   List[str]    		=		[int(item) for item in user_input.split(""",""")]
  
   snake_case   :   Union[str, Any]    		=		input("""Enter a single number to be found in the list:\n""")
   snake_case   :   str    		=		int(target_input)
   snake_case   :   Any    		=		sentinel_linear_search(sequence, target)
   if result is not None:
    print(f"""{target} found at positions: {result}""")
   else:
    print("""Not found""")