


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_distilbert import DistilBertTokenizer


__a	 =      logging.get_logger(__name__)

__a	 =      {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

__a	 =      {
    """vocab_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/vocab.txt""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/vocab.txt""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/vocab.txt"""
        ),
        """distilbert-base-german-cased""": """https://huggingface.co/distilbert-base-german-cased/resolve/main/vocab.txt""",
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/vocab.txt"""
        ),
    },
    """tokenizer_file""": {
        """distilbert-base-uncased""": """https://huggingface.co/distilbert-base-uncased/resolve/main/tokenizer.json""",
        """distilbert-base-uncased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-uncased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-cased""": """https://huggingface.co/distilbert-base-cased/resolve/main/tokenizer.json""",
        """distilbert-base-cased-distilled-squad""": (
            """https://huggingface.co/distilbert-base-cased-distilled-squad/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-german-cased""": (
            """https://huggingface.co/distilbert-base-german-cased/resolve/main/tokenizer.json"""
        ),
        """distilbert-base-multilingual-cased""": (
            """https://huggingface.co/distilbert-base-multilingual-cased/resolve/main/tokenizer.json"""
        ),
    },
}

__a	 =      {
    """distilbert-base-uncased""": 512,
    """distilbert-base-uncased-distilled-squad""": 512,
    """distilbert-base-cased""": 512,
    """distilbert-base-cased-distilled-squad""": 512,
    """distilbert-base-german-cased""": 512,
    """distilbert-base-multilingual-cased""": 512,
}


__a	 =      {
    """distilbert-base-uncased""": {"""do_lower_case""": True},
    """distilbert-base-uncased-distilled-squad""": {"""do_lower_case""": True},
    """distilbert-base-cased""": {"""do_lower_case""": False},
    """distilbert-base-cased-distilled-squad""": {"""do_lower_case""": False},
    """distilbert-base-german-cased""": {"""do_lower_case""": False},
    """distilbert-base-multilingual-cased""": {"""do_lower_case""": False},
}






class 	__lowercase					(	__snake_case	):
      UpperCamelCase										=							VOCAB_FILES_NAMES
      UpperCamelCase										=							PRETRAINED_VOCAB_FILES_MAP
      UpperCamelCase										=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      UpperCamelCase										=							PRETRAINED_INIT_CONFIGURATION
      UpperCamelCase										=							['''input_ids''', '''attention_mask''']
      UpperCamelCase										=							DistilBertTokenizer





      def __init__(		self    :       str       ,							__lowerCamelCase    :       Any=None       ,							__lowerCamelCase    :       Tuple=None       ,							__lowerCamelCase    :       Any=True       ,							__lowerCamelCase    :       Dict="[UNK]"       ,							__lowerCamelCase    :       Any="[SEP]"       ,							__lowerCamelCase    :       str="[PAD]"       ,							__lowerCamelCase    :       Tuple="[CLS]"       ,							__lowerCamelCase    :       Dict="[MASK]"       ,							__lowerCamelCase    :       Any=True       ,							__lowerCamelCase    :       Tuple=None       ,							**__lowerCamelCase    :       Union[str, Any]       ,							)     -> Any:






         """simple docstring"""







         super().__init__(
             __lowerCamelCase       ,							tokenizer_file=__lowerCamelCase       ,							do_lower_case=__lowerCamelCase       ,							unk_token=__lowerCamelCase       ,							sep_token=__lowerCamelCase       ,							pad_token=__lowerCamelCase       ,							cls_token=__lowerCamelCase       ,							mask_token=__lowerCamelCase       ,							tokenize_chinese_chars=__lowerCamelCase       ,							strip_accents=__lowerCamelCase       ,							**__lowerCamelCase       ,							)

         UpperCAmelCase      					=  json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
         if (
             normalizer_state.get("""lowercase"""       ,							__lowerCamelCase							) != do_lower_case
             or normalizer_state.get("""strip_accents"""       ,							__lowerCamelCase							) != strip_accents
             or normalizer_state.get("""handle_chinese_chars"""       ,							__lowerCamelCase							) != tokenize_chinese_chars
         ):
            UpperCAmelCase      					=  getattr(__lowerCamelCase       ,							normalizer_state.pop("""type"""							)							)
            UpperCAmelCase      					=  do_lower_case
            UpperCAmelCase      					=  strip_accents
            UpperCAmelCase      					=  tokenize_chinese_chars
            UpperCAmelCase      					=  normalizer_class(**__lowerCamelCase							)

         UpperCAmelCase      					=  do_lower_case





      def 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       Any=None							)     -> Any:






         """simple docstring"""







         UpperCAmelCase      					=  [self.cls_token_id] + token_ids_a + [self.sep_token_id]

         if token_ids_a:
            output += token_ids_a + [self.sep_token_id]

         return output





      def 							_lowercase					(		self    :       Dict       ,							__lowerCamelCase    :       List[int]       ,							__lowerCamelCase    :       Optional[List[int]] = None							)     -> List[int]:






         """simple docstring"""







         UpperCAmelCase      					=  [self.sep_token_id]
         UpperCAmelCase      					=  [self.cls_token_id]
         if token_ids_a is None:
            return len(cls + token_ids_a + sep							) * [0]
         return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + sep							) * [1]





      def 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       str       ,							__lowerCamelCase    :       Optional[str] = None							)     -> Tuple[str]:






         """simple docstring"""







         UpperCAmelCase      					=  self._tokenizer.model.save(__lowerCamelCase       ,							name=__lowerCamelCase							)
         return tuple(__lowerCamelCase							)







from __future__ import annotations
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Optional[int]:
   # Checks if the entire collection has been sorted
   if len(lowerCAmelCase_ ) <= 1 or n <= 1:
      return

   insert_next(lowerCAmelCase_	,    n - 1 )
   rec_insertion_sort(lowerCAmelCase_	,    n - 1 )
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Dict:
   # Checks order between adjacent elements
   if index >= len(lowerCAmelCase_ ) or collection[index - 1] <= collection[index]:
      return

   # Swaps adjacent elements since they are not in ascending order
   UpperCAmelCase					,	UpperCAmelCase      					=  (
       collection[index],
       collection[index - 1],
   )

   insert_next(lowerCAmelCase_	,    index + 1 )


if __name__ == "__main__":
 __a	 =      input("""Enter integers separated by spaces: """)
 __a	 =      [int(num) for num in numbers.split()]
 rec_insertion_sort(number_list, len(number_list))
 print(number_list)



