


'''simple docstring'''






import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


__A   :    Optional[Any]											= logging.get_logger(__name__)

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

__A   :    Optional[int]											= {
    "vocab_file": {
        "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt",
        "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt",
        "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/vocab.txt",
        "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/vocab.txt",
        "bert-base-multilingual-uncased": (
            "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt"
        ),
        "bert-base-multilingual-cased": "https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt",
        "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt",
        "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt",
        "bert-large-uncased-whole-word-masking": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt"
        ),
        "bert-large-cased-whole-word-masking": (
            "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt"
        ),
        "bert-large-uncased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"
        ),
        "bert-large-cased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt"
        ),
        "bert-base-cased-finetuned-mrpc": (
            "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt"
        ),
        "bert-base-german-dbmdz-cased": "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt",
        "bert-base-german-dbmdz-uncased": (
            "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt"
        ),
        "TurkuNLP/bert-base-finnish-cased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt"
        ),
        "TurkuNLP/bert-base-finnish-uncased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt"
        ),
        "wietsedv/bert-base-dutch-cased": (
            "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "bert-base-uncased": "https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json",
        "bert-large-uncased": "https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json",
        "bert-base-cased": "https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json",
        "bert-large-cased": "https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json",
        "bert-base-multilingual-uncased": (
            "https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json"
        ),
        "bert-base-multilingual-cased": (
            "https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json"
        ),
        "bert-base-chinese": "https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json",
        "bert-base-german-cased": "https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json",
        "bert-large-uncased-whole-word-masking": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json"
        ),
        "bert-large-cased-whole-word-masking": (
            "https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json"
        ),
        "bert-large-uncased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"
        ),
        "bert-large-cased-whole-word-masking-finetuned-squad": (
            "https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json"
        ),
        "bert-base-cased-finetuned-mrpc": (
            "https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json"
        ),
        "bert-base-german-dbmdz-cased": (
            "https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json"
        ),
        "bert-base-german-dbmdz-uncased": (
            "https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json"
        ),
        "TurkuNLP/bert-base-finnish-cased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json"
        ),
        "TurkuNLP/bert-base-finnish-uncased-v1": (
            "https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json"
        ),
        "wietsedv/bert-base-dutch-cased": (
            "https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json"
        ),
    },
}

__A   :    int											= {
    "bert-base-uncased": 512,
    "bert-large-uncased": 512,
    "bert-base-cased": 512,
    "bert-large-cased": 512,
    "bert-base-multilingual-uncased": 512,
    "bert-base-multilingual-cased": 512,
    "bert-base-chinese": 512,
    "bert-base-german-cased": 512,
    "bert-large-uncased-whole-word-masking": 512,
    "bert-large-cased-whole-word-masking": 512,
    "bert-large-uncased-whole-word-masking-finetuned-squad": 512,
    "bert-large-cased-whole-word-masking-finetuned-squad": 512,
    "bert-base-cased-finetuned-mrpc": 512,
    "bert-base-german-dbmdz-cased": 512,
    "bert-base-german-dbmdz-uncased": 512,
    "TurkuNLP/bert-base-finnish-cased-v1": 512,
    "TurkuNLP/bert-base-finnish-uncased-v1": 512,
    "wietsedv/bert-base-dutch-cased": 512,
}

__A   :    Tuple											= {
    "bert-base-uncased": {"do_lower_case": True},
    "bert-large-uncased": {"do_lower_case": True},
    "bert-base-cased": {"do_lower_case": False},
    "bert-large-cased": {"do_lower_case": False},
    "bert-base-multilingual-uncased": {"do_lower_case": True},
    "bert-base-multilingual-cased": {"do_lower_case": False},
    "bert-base-chinese": {"do_lower_case": False},
    "bert-base-german-cased": {"do_lower_case": False},
    "bert-large-uncased-whole-word-masking": {"do_lower_case": True},
    "bert-large-cased-whole-word-masking": {"do_lower_case": False},
    "bert-large-uncased-whole-word-masking-finetuned-squad": {"do_lower_case": True},
    "bert-large-cased-whole-word-masking-finetuned-squad": {"do_lower_case": False},
    "bert-base-cased-finetuned-mrpc": {"do_lower_case": False},
    "bert-base-german-dbmdz-cased": {"do_lower_case": False},
    "bert-base-german-dbmdz-uncased": {"do_lower_case": True},
    "TurkuNLP/bert-base-finnish-cased-v1": {"do_lower_case": False},
    "TurkuNLP/bert-base-finnish-uncased-v1": {"do_lower_case": True},
    "wietsedv/bert-base-dutch-cased": {"do_lower_case": False},
}






class   __snake_case			(  _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    lowercase  					=   VOCAB_FILES_NAMES
    lowercase  					=   PRETRAINED_VOCAB_FILES_MAP
    lowercase  					=   PRETRAINED_INIT_CONFIGURATION
    lowercase  					=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowercase  					=   BertTokenizer

    def __init__(  self       :    Tuple       ,		lowerCamelCase       :    Dict=None       ,		lowerCamelCase       :    List[str]=None       ,		lowerCamelCase       :    List[Any]=True       ,		lowerCamelCase       :    Union[str, Any]="[UNK]"       ,		lowerCamelCase       :    List[str]="[SEP]"       ,		lowerCamelCase       :    List[Any]="[PAD]"       ,		lowerCamelCase       :    Tuple="[CLS]"       ,		lowerCamelCase       :    str="[MASK]"       ,		lowerCamelCase       :    Any=True       ,		lowerCamelCase       :    Dict=None       ,		**lowerCamelCase       :    Dict       ,		)  ->    Dict:
      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       ,		)

      lowerCAmelCase_     : Union[str, Any]     =  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
      ):
        lowerCAmelCase_     : Optional[int]     =  getattr(lowerCamelCase       ,		normalizer_state.pop("""type"""						)						)
        lowerCAmelCase_     : Optional[int]     =  do_lower_case
        lowerCAmelCase_     : Dict     =  strip_accents
        lowerCAmelCase_     : Tuple     =  tokenize_chinese_chars
        lowerCAmelCase_     : Any     =  normalizer_class(**lowerCamelCase						)

      lowerCAmelCase_     : Optional[Any]     =  do_lower_case

    def __lowercase  (  self       :    Optional[int]       ,		lowerCamelCase       :    Tuple       ,		lowerCamelCase       :    Dict=None						)  ->    Optional[Any]:
      lowerCAmelCase_     : List[str]     =  [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       :    Tuple       ,		lowerCamelCase       :    List[int]       ,		lowerCamelCase       :    Optional[List[int]] = None						)  ->    List[int]:
      lowerCAmelCase_     : Dict     =  [self.sep_token_id]
      lowerCAmelCase_     : Tuple     =  [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]:
      lowerCAmelCase_     : Optional[Any]     =  self._tokenizer.model.save(lowerCamelCase       ,		name=lowerCamelCase						)
      return tuple(lowerCamelCase						)







'''simple docstring'''






from __future__ import annotations







def 							UpperCamelCase_     (       A__   :  list				,       A__   :  int				,       A__   :  int				,       A__   :  int   ):
  '''simple docstring'''





  lowerCAmelCase_     : int     =  []
  lowerCAmelCase_,				lowerCAmelCase_     : Any     =  input_list[low:mid], input_list[mid : high + 1]
  while left and right:
    result.append((left if left[0] <= right[0] else right).pop(0   )   )
  lowerCAmelCase_     : Dict     =  result + left + right
  return input_list







def 							UpperCamelCase_     (       A__   :  list   ):
  '''simple docstring'''





  if len(A__   ) <= 1:
    return input_list
  lowerCAmelCase_     : str     =  list(A__   )

  # iteration for two-way merging
  lowerCAmelCase_     : Dict     =  2
  while p <= len(A__   ):
    # getting low, high and middle value for merge-sort of single list
    for i in range(0				,       len(A__   )				,       A__   ):
      lowerCAmelCase_     : Tuple     =  i
      lowerCAmelCase_     : List[str]     =  i + p - 1
      lowerCAmelCase_     : Optional[Any]     =  (low + high + 1) // 2
      lowerCAmelCase_     : List[str]     =  merge(A__				,       A__				,       A__				,       A__   )
    # final merge of last two parts
    if p * 2 >= len(A__   ):
      lowerCAmelCase_     : Union[str, Any]     =  i
      lowerCAmelCase_     : Dict     =  merge(A__				,       0				,       A__				,       len(A__   ) - 1   )
      break
    p *= 2

  return input_list


if __name__ == "__main__":
  __A   :    int											= input("Enter numbers separated by a comma:\n").strip()
  if user_input == "":
    __A   :    str											= []
  else:
    __A   :    Optional[Any]											= [int(item.strip()) for item in user_input.split(",")]
  print(iter_merge_sort(unsorted))



