






"""simple docstring"""






import json
import os
from functools import lru_cache
from typing import List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


A_			  =    logging.get_logger(__name__)

A_			  =    {
    "vocab_file": "vocab.json",
    "merges_file": "merges.txt",
}

A_			  =    {
    "vocab_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/vocab.json",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/vocab.json",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/vocab.json",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/vocab.json",
        "roberta-base-openai-detector": "https://huggingface.co/roberta-base-openai-detector/resolve/main/vocab.json",
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/vocab.json"
        ),
    },
    "merges_file": {
        "roberta-base": "https://huggingface.co/roberta-base/resolve/main/merges.txt",
        "roberta-large": "https://huggingface.co/roberta-large/resolve/main/merges.txt",
        "roberta-large-mnli": "https://huggingface.co/roberta-large-mnli/resolve/main/merges.txt",
        "distilroberta-base": "https://huggingface.co/distilroberta-base/resolve/main/merges.txt",
        "roberta-base-openai-detector": "https://huggingface.co/roberta-base-openai-detector/resolve/main/merges.txt",
        "roberta-large-openai-detector": (
            "https://huggingface.co/roberta-large-openai-detector/resolve/main/merges.txt"
        ),
    },
}

A_			  =    {
    "roberta-base": 512,
    "roberta-large": 512,
    "roberta-large-mnli": 512,
    "distilroberta-base": 512,
    "roberta-base-openai-detector": 512,
    "roberta-large-openai-detector": 512,
}




@lru_cache()
def 						_UpperCamelCase			(  ):
   UpperCamelCase_     =(
       list(range(ord("!"			)    ,       ord("~"			) + 1			)			) + list(range(ord("¡"			)    ,       ord("¬"			) + 1			)			) + list(range(ord("®"			)    ,       ord("ÿ"			) + 1			)			)
   )
   UpperCamelCase_     =bs[:]
   UpperCamelCase_     =0
   for b in range(2**8			):
      if b not in bs:
         bs.append(A			)
         cs.append(2**8 + n			)
         n += 1
   UpperCamelCase_     =[chr(A			) for n in cs]
   return dict(zip(A    ,       A			)			)




def 						_UpperCamelCase			(  A			):
   UpperCamelCase_     =set()
   UpperCamelCase_     =word[0]
   for char in word[1:]:
      pairs.add((prev_char, char)			)
      UpperCamelCase_     =char
   return pairs
class 						__lowerCAmelCase   (			UpperCAmelCase       ):







  '''simple docstring'''


  __lowerCamelCase       :    Any     	=			VOCAB_FILES_NAMES
  __lowerCamelCase       :    List[str]     	=			PRETRAINED_VOCAB_FILES_MAP
  __lowerCamelCase       :    int     	=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  __lowerCamelCase       :    Dict     	=			["input_ids", "attention_mask"]
  def __init__(      self:		Dict				,			UpperCamelCase_:		List[Any]				,			UpperCamelCase_:		Tuple				,			UpperCamelCase_:		List[Any]="replace"				,			UpperCamelCase_:		Union[str, Any]="<s>"				,			UpperCamelCase_:		int="</s>"				,			UpperCamelCase_:		Optional[int]="</s>"				,			UpperCamelCase_:		List[str]="<s>"				,			UpperCamelCase_:		Tuple="<unk>"				,			UpperCamelCase_:		Tuple="<pad>"				,			UpperCamelCase_:		Optional[Any]="<mask>"				,			UpperCamelCase_:		Tuple=False				,			**UpperCamelCase_:		int				,			):
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else bos_token
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else eos_token
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else sep_token
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else cls_token
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else unk_token
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else pad_token

     # Mask token behave like a normal word, i.e. include the space before it
     UpperCamelCase_     =AddedToken(UpperCamelCase_				,			lstrip=UpperCamelCase_				,			rstrip=UpperCamelCase_					) if isinstance(UpperCamelCase_				,			UpperCamelCase_					) else mask_token

     super().__init__(
         errors=UpperCamelCase_				,			bos_token=UpperCamelCase_				,			eos_token=UpperCamelCase_				,			unk_token=UpperCamelCase_				,			sep_token=UpperCamelCase_				,			cls_token=UpperCamelCase_				,			pad_token=UpperCamelCase_				,			mask_token=UpperCamelCase_				,			add_prefix_space=UpperCamelCase_				,			**UpperCamelCase_				,			)

     with open(UpperCamelCase_				,			encoding="utf-8"					) as vocab_handle:
        UpperCamelCase_     =json.load(UpperCamelCase_					)
     UpperCamelCase_     ={v: k for k, v in self.encoder.items()}
     UpperCamelCase_     =errors  # how to handle errors in decoding
     UpperCamelCase_     =bytes_to_unicode()
     UpperCamelCase_     ={v: k for k, v in self.byte_encoder.items()}
     with open(UpperCamelCase_				,			encoding="utf-8"					) as merges_handle:
        UpperCamelCase_     =merges_handle.read().split("\n"					)[1:-1]
     UpperCamelCase_     =[tuple(merge.split()					) for merge in bpe_merges]
     UpperCamelCase_     =dict(zip(UpperCamelCase_				,			range(len(UpperCamelCase_					)					)					)					)
     UpperCamelCase_     ={}
     UpperCamelCase_     =add_prefix_space

     # Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
     UpperCamelCase_     =re.compile(r"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"					)
  @property
  def 					UpperCamelCase__   (      self:		str					):
     return len(self.encoder					)
  def 					UpperCamelCase__   (      self:		List[str]					):
     return dict(self.encoder				,			**self.added_tokens_encoder					)
  def 					UpperCamelCase__   (      self:		Tuple				,			UpperCamelCase_:		Optional[Any]					):
     if token in self.cache:
        return self.cache[token]
     UpperCamelCase_     =tuple(UpperCamelCase_					)
     UpperCamelCase_     =get_pairs(UpperCamelCase_					)

     if not pairs:
        return token

     while True:
        UpperCamelCase_     =min(UpperCamelCase_				,			key=lambda UpperCamelCase_					: self.bpe_ranks.get(UpperCamelCase_				,			float("inf"					)					)					)
        if bigram not in self.bpe_ranks:
           break
        UpperCamelCase_    ,							UpperCamelCase_     =bigram
        UpperCamelCase_     =[]
        UpperCamelCase_     =0
        while i < len(UpperCamelCase_					):
           try:
              UpperCamelCase_     =word.index(UpperCamelCase_				,			UpperCamelCase_					)
           except ValueError:
              new_word.extend(word[i:]					)
              break
           else:
              new_word.extend(word[i:j]					)
              UpperCamelCase_     =j

           if word[i] == first and i < len(UpperCamelCase_					) - 1 and word[i + 1] == second:
              new_word.append(first + second					)
              i += 2
           else:
              new_word.append(word[i]					)
              i += 1
        UpperCamelCase_     =tuple(UpperCamelCase_					)
        UpperCamelCase_     =new_word
        if len(UpperCamelCase_					) == 1:
           break
        else:
           UpperCamelCase_     =get_pairs(UpperCamelCase_					)
     UpperCamelCase_     =" ".join(UpperCamelCase_					)
     UpperCamelCase_     =word
     return word
  def 					UpperCamelCase__   (      self:		Tuple				,			UpperCamelCase_:		Union[str, Any]					):
     UpperCamelCase_     =[]
     for token in re.findall(self.pat				,			UpperCamelCase_					):
        UpperCamelCase_     ="".join(
            self.byte_encoder[b] for b in token.encode("utf-8"					)					)  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
        bpe_tokens.extend(bpe_token for bpe_token in self.bpe(UpperCamelCase_					).split(" "					)					)
     return bpe_tokens
  def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		Optional[int]					):
     return self.encoder.get(UpperCamelCase_				,			self.encoder.get(self.unk_token					)					)
  def 					UpperCamelCase__   (      self:		Optional[Any]				,			UpperCamelCase_:		List[str]					):
     return self.decoder.get(UpperCamelCase_					)
  def 					UpperCamelCase__   (      self:		str				,			UpperCamelCase_:		str					):
     UpperCamelCase_     ="".join(UpperCamelCase_					)
     UpperCamelCase_     =bytearray([self.byte_decoder[c] for c in text]					).decode("utf-8"				,			errors=self.errors					)
     return text
  def 					UpperCamelCase__   (      self:		Optional[int]				,			UpperCamelCase_:		str				,			UpperCamelCase_:		Optional[str] = None					):
     if not os.path.isdir(UpperCamelCase_					):
        logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""					)
        return
     UpperCamelCase_     =os.path.join(
         UpperCamelCase_				,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]					)
     UpperCamelCase_     =os.path.join(
         UpperCamelCase_				,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"]					)

     with open(UpperCamelCase_				,			"w"				,			encoding="utf-8"					) as f:
        f.write(json.dumps(self.encoder				,			indent=2				,			sort_keys=UpperCamelCase_				,			ensure_ascii=UpperCamelCase_					) + "\n"					)

     UpperCamelCase_     =0
     with open(UpperCamelCase_				,			"w"				,			encoding="utf-8"					) as writer:
        writer.write("#version: 0.2\n"					)
        for bpe_tokens, token_index in sorted(self.bpe_ranks.items()				,			key=lambda UpperCamelCase_					: kv[1]					):
           if index != token_index:
              logger.warning(
                  f"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
                  " Please check that the tokenizer is not corrupted!"					)
              UpperCamelCase_     =token_index
           writer.write(" ".join(UpperCamelCase_					) + "\n"					)
           index += 1

     return vocab_file, merge_file
  def 					UpperCamelCase__   (      self:		int				,			UpperCamelCase_:		List[int]				,			UpperCamelCase_:		Optional[List[int]] = None					):
     if token_ids_a is None:
        return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
     UpperCamelCase_     =[self.cls_token_id]
     UpperCamelCase_     =[self.sep_token_id]
     return cls + token_ids_a + sep + sep + token_ids_a + sep
  def 					UpperCamelCase__   (      self:		Union[str, Any]				,			UpperCamelCase_:		List[int]				,			UpperCamelCase_:		Optional[List[int]] = None				,			UpperCamelCase_:		bool = False					):
     if already_has_special_tokens:
        return super().get_special_tokens_mask(
            token_ids_a=UpperCamelCase_				,			token_ids_a=UpperCamelCase_				,			already_has_special_tokens=UpperCamelCase_					)

     if token_ids_a is None:
        return [1] + ([0] * len(UpperCamelCase_					)) + [1]
     return [1] + ([0] * len(UpperCamelCase_					)) + [1, 1] + ([0] * len(UpperCamelCase_					)) + [1]
  def 					UpperCamelCase__   (      self:		Union[str, Any]				,			UpperCamelCase_:		List[int]				,			UpperCamelCase_:		Optional[List[int]] = None					):
     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 + sep + token_ids_a + sep					) * [0]





  def 					UpperCamelCase__   (      self:		Union[str, Any]				,			UpperCamelCase_:		Tuple				,			UpperCamelCase_:		Any=False				,			**UpperCamelCase_:		Dict					):
     UpperCamelCase_     =kwargs.pop("add_prefix_space"				,			self.add_prefix_space					)
     if (is_split_into_words or add_prefix_space) and (len(UpperCamelCase_					) > 0 and not text[0].isspace()):
        UpperCamelCase_     =" " + text
     return (text, kwargs)








"""simple docstring"""






from collections import defaultdict




def 						_UpperCamelCase			(  A = 5			):
   UpperCamelCase_     =defaultdict(A			)
   UpperCamelCase_     =0

   while True:
      UpperCamelCase_     =get_digits(A			)
      freqs[digits].append(A			)

      if len(freqs[digits]			) == max_base:
         UpperCamelCase_     =freqs[digits][0] ** 3
         return base

      num += 1




def 						_UpperCamelCase			(  A			):
   return "".join(sorted(str(num**3			)			)			)


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