


'''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_squeezebert import SqueezeBertTokenizer


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

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

__A					:  Union[str, Any]											=      {
    "vocab_file": {
        "squeezebert/squeezebert-uncased": (
            "https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/vocab.txt"
        ),
        "squeezebert/squeezebert-mnli": "https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/vocab.txt",
        "squeezebert/squeezebert-mnli-headless": (
            "https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/vocab.txt"
        ),
    },
    "tokenizer_file": {
        "squeezebert/squeezebert-uncased": (
            "https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/tokenizer.json"
        ),
        "squeezebert/squeezebert-mnli": (
            "https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/tokenizer.json"
        ),
        "squeezebert/squeezebert-mnli-headless": (
            "https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/tokenizer.json"
        ),
    },
}

__A					:  int											=      {
    "squeezebert/squeezebert-uncased": 512,
    "squeezebert/squeezebert-mnli": 512,
    "squeezebert/squeezebert-mnli-headless": 512,
}


__A					:  Union[str, Any]											=      {
    "squeezebert/squeezebert-uncased": {"do_lower_case": True},
    "squeezebert/squeezebert-mnli": {"do_lower_case": True},
    "squeezebert/squeezebert-mnli-headless": {"do_lower_case": True},
}






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    =					SqueezeBertTokenizer

    def __init__(   self    :  str    ,						lowerCamelCase    :  int=None    ,						lowerCamelCase    :  Optional[int]=None    ,						lowerCamelCase    :  List[str]=True    ,						lowerCamelCase    :  List[Any]="[UNK]"    ,						lowerCamelCase    :  Dict="[SEP]"    ,						lowerCamelCase    :  str="[PAD]"    ,						lowerCamelCase    :  Union[str, Any]="[CLS]"    ,						lowerCamelCase    :  List[str]="[MASK]"    ,						lowerCamelCase    :  List[Any]=True    ,						lowerCamelCase    :  List[str]=None    ,						**lowerCamelCase    :  Tuple    ,						)   ->  str:
      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_			:      Dict			=   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_			:      Any			=   getattr(lowerCamelCase    ,						normalizer_state.pop("""type"""		)		)
        lowerCAmelCase_			:      Union[str, Any]			=   do_lower_case
        lowerCAmelCase_			:      str			=   strip_accents
        lowerCAmelCase_			:      int			=   tokenize_chinese_chars
        lowerCAmelCase_			:      str			=   normalizer_class(**lowerCamelCase		)

      lowerCAmelCase_			:      List[str]			=   do_lower_case

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







'''simple docstring'''






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





  lowerCAmelCase_			:      Union[str, Any]			=   (1 + 24 * n) ** 0.5
  return ((1 + root) / 6) % 1 == 0







def 				UpperCamelCase_			(    A__					:   int = 50_00					):
  '''simple docstring'''





  lowerCAmelCase_			:      Optional[int]			=   [(i * (3 * i - 1)) // 2 for i in range(1							,    A__					)]
  for i, pentagonal_i in enumerate(A__					):
    for j in range(A__							,    len(A__					)					):
      lowerCAmelCase_			:      int			=   pentagonal_nums[j]
      lowerCAmelCase_			:      Union[str, Any]			=   pentagonal_i + pentagonal_j
      lowerCAmelCase_			:      List[Any]			=   pentagonal_j - pentagonal_i
      if is_pentagonal(A__					) and is_pentagonal(A__					):
        return b

  return -1


if __name__ == "__main__":
  print(F'''{solution() = }''')



