code: 
  
  
  
  
  
  
  """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)
  
style_context: 
  
  
  
  
  
  
  """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() = }''')
  