"""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'''}

# See all BART models at https://huggingface.co/models?filter=bart
__A     = {
    '''vocab_file''': {
        '''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/vocab.json''',
        '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/vocab.json''',
        '''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json''',
        '''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json''',
        '''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json''',
        '''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''facebook/bart-base''': '''https://huggingface.co/facebook/bart-base/resolve/main/merges.txt''',
        '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/merges.txt''',
        '''facebook/bart-large-mnli''': '''https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt''',
        '''facebook/bart-large-cnn''': '''https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt''',
        '''facebook/bart-large-xsum''': '''https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt''',
        '''yjernite/bart_eli5''': '''https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt''',
    },
}

__A     = {
    '''facebook/bart-base''': 1024,
    '''facebook/bart-large''': 1024,
    '''facebook/bart-large-mnli''': 1024,
    '''facebook/bart-large-cnn''': 1024,
    '''facebook/bart-large-xsum''': 1024,
    '''yjernite/bart_eli5''': 1024,
}


@lru_cache()
def       lowercase_      (      )       ->					List[Any]:



							'''simple docstring'''

							__lowerCamelCase    :						Dict						      =   (
							    list(range(ord("!"					)  ,      ord("~"					) + 1					)					) + list(range(ord("¡"					)  ,      ord("¬"					) + 1					)					) + list(range(ord("®"					)  ,      ord("ÿ"					) + 1					)					)
							)
							__lowerCamelCase    :						Union[str, Any]						      =   bs[:]
							__lowerCamelCase    :						Optional[int]						      =   0
							for b in range(2**8					):
														if b not in bs:
																					bs.append(_SCREAMING_SNAKE_CASE					)
																					cs.append(2**8 + n					)
																					n += 1
							__lowerCamelCase    :						List[str]						      =   [chr(_SCREAMING_SNAKE_CASE					) for n in cs]
							return dict(zip(_SCREAMING_SNAKE_CASE  ,      _SCREAMING_SNAKE_CASE					)					)


def       lowercase_      (      _lowerCamelCase:		Tuple					)       ->					Tuple:



							'''simple docstring'''

							__lowerCamelCase    :						Union[str, Any]						      =   set()
							__lowerCamelCase    :						str						      =   word[0]
							for char in word[1:]:
														pairs.add((prev_char, char)					)
														__lowerCamelCase    :						Optional[int]						      =   char
							return pairs







class        _snake_case   (    a__						):
						snake_case__	     =	VOCAB_FILES_NAMES
						snake_case__	     =	PRETRAINED_VOCAB_FILES_MAP
						snake_case__	     =	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
						snake_case__	     =	["""input_ids""", """attention_mask"""]






						def __init__(				self					:	Dict							,    UpperCAmelCase					:	Tuple							,    UpperCAmelCase					:	Optional[int]							,    UpperCAmelCase					:	Optional[int]="replace"							,    UpperCAmelCase					:	Optional[int]="<s>"							,    UpperCAmelCase					:	Optional[int]="</s>"							,    UpperCAmelCase					:	Any="</s>"							,    UpperCAmelCase					:	Tuple="<s>"							,    UpperCAmelCase					:	List[Any]="<unk>"							,    UpperCAmelCase					:	Optional[Any]="<pad>"							,    UpperCAmelCase					:	Tuple="<mask>"							,    UpperCAmelCase					:	Tuple=False							,    **UpperCAmelCase					:	Optional[Any]							,    ):
													__lowerCamelCase    :						List[Any]						      =   AddedToken(__UpperCAmelCase							,    lstrip=__UpperCAmelCase							,    rstrip=__UpperCAmelCase			) if isinstance(__UpperCAmelCase							,    __UpperCAmelCase			) else bos_token
													__lowerCamelCase    :						int						      =   AddedToken(__UpperCAmelCase							,    lstrip=__UpperCAmelCase							,    rstrip=__UpperCAmelCase			) if isinstance(__UpperCAmelCase							,    __UpperCAmelCase			) else eos_token
													__lowerCamelCase    :						Optional[Any]						      =   AddedToken(__UpperCAmelCase							,    lstrip=__UpperCAmelCase							,    rstrip=__UpperCAmelCase			) if isinstance(__UpperCAmelCase							,    __UpperCAmelCase			) else sep_token
													__lowerCamelCase    :						str						      =   AddedToken(__UpperCAmelCase							,    lstrip=__UpperCAmelCase							,    rstrip=__UpperCAmelCase			) if isinstance(__UpperCAmelCase							,    __UpperCAmelCase			) else cls_token
													__lowerCamelCase    :						Optional[Any]						      =   AddedToken(__UpperCAmelCase							,    lstrip=__UpperCAmelCase							,    rstrip=__UpperCAmelCase			) if isinstance(__UpperCAmelCase							,    __UpperCAmelCase			) else unk_token
													__lowerCamelCase    :						Optional[int]						      =   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
													__lowerCamelCase    :						Union[str, Any]						      =   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:
																				__lowerCamelCase    :						int						      =   json.load(__UpperCAmelCase			)
													__lowerCamelCase    :						Dict						      =   {v: k for k, v in self.encoder.items()}
													__lowerCamelCase    :						List[Any]						      =   errors  # how to handle errors in decoding
													__lowerCamelCase    :						Optional[int]						      =   bytes_to_unicode()
													__lowerCamelCase    :						Tuple						      =   {v: k for k, v in self.byte_encoder.items()}
													with open(__UpperCAmelCase							,    encoding="utf-8"			) as merges_handle:
																				__lowerCamelCase    :						List[Any]						      =   merges_handle.read().split("\n"			)[1:-1]
													__lowerCamelCase    :						List[Any]						      =   [tuple(merge.split()			) for merge in bpe_merges]
													__lowerCamelCase    :						Any						      =   dict(zip(__UpperCAmelCase							,    range(len(__UpperCAmelCase			)			)			)			)
													__lowerCamelCase    :						Union[str, Any]						      =   {}
													__lowerCamelCase    :						List[Any]						      =   add_prefix_space

													# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
													__lowerCamelCase    :						str						      =   re.compile(r"\'s|\'t|\'re|\'ve|\'m|\'ll|\'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"			)






						@property
						def 					lowerCamelCase__   (				self					:	Optional[int]			):
													return len(self.encoder			)






						def 					lowerCamelCase__   (				self					:	Union[str, Any]			):
													return dict(self.encoder							,    **self.added_tokens_encoder			)






						def 					lowerCamelCase__   (				self					:	Dict							,    UpperCAmelCase					:	Union[str, Any]			):

													if token in self.cache:
																				return self.cache[token]
													__lowerCamelCase    :						List[Any]						      =   tuple(__UpperCAmelCase			)
													__lowerCamelCase    :						Dict						      =   get_pairs(__UpperCAmelCase			)

													if not pairs:
																				return token

													while True:
																				__lowerCamelCase    :						str						      =   min(__UpperCAmelCase							,    key=lambda UpperCAmelCase			: self.bpe_ranks.get(__UpperCAmelCase							,    float("inf"			)			)			)
																				if bigram not in self.bpe_ranks:
																											break
																				__lowerCamelCase    :						List[str]						      =   bigram
																				__lowerCamelCase    :						Dict						      =   []
																				__lowerCamelCase    :						Optional[Any]						      =   0
																				while i < len(__UpperCAmelCase			):
																											try:
																																		__lowerCamelCase    :						List[Any]						      =   word.index(__UpperCAmelCase							,    __UpperCAmelCase			)
																											except ValueError:
																																		new_word.extend(word[i:]			)
																																		break
																											else:
																																		new_word.extend(word[i:j]			)
																																		__lowerCamelCase    :						Dict						      =   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
																				__lowerCamelCase    :						Union[str, Any]						      =   tuple(__UpperCAmelCase			)
																				__lowerCamelCase    :						Union[str, Any]						      =   new_word
																				if len(__UpperCAmelCase			) == 1:
																											break
																				else:
																											__lowerCamelCase    :						Dict						      =   get_pairs(__UpperCAmelCase			)
													__lowerCamelCase    :						str						      =   ' '.join(__UpperCAmelCase			)
													__lowerCamelCase    :						Optional[Any]						      =   word
													return word






						def 					lowerCamelCase__   (				self					:	List[Any]							,    UpperCAmelCase					:	int			):
													__lowerCamelCase    :						str						      =   []
													for token in re.findall(self.pat							,    __UpperCAmelCase			):
																				__lowerCamelCase    :						Dict						      =   ''.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 					lowerCamelCase__   (				self					:	Dict							,    UpperCAmelCase					:	Optional[Any]			):
													return self.encoder.get(__UpperCAmelCase							,    self.encoder.get(self.unk_token			)			)






						def 					lowerCamelCase__   (				self					:	Union[str, Any]							,    UpperCAmelCase					:	Optional[int]			):
													return self.decoder.get(__UpperCAmelCase			)






						def 					lowerCamelCase__   (				self					:	int							,    UpperCAmelCase					:	str			):
													__lowerCamelCase    :						Optional[int]						      =   ''.join(__UpperCAmelCase			)
													__lowerCamelCase    :						Tuple						      =   bytearray([self.byte_decoder[c] for c in text]			).decode("utf-8"							,    errors=self.errors			)
													return text






						def 					lowerCamelCase__   (				self					:	Dict							,    UpperCAmelCase					:	List[str]							,    UpperCAmelCase					:	str = None			):

													if not os.path.isdir(__UpperCAmelCase			):
																				logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""			)
																				return
													__lowerCamelCase    :						Optional[int]						      =   os.path.join(
													    __UpperCAmelCase							,    (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]			)
													__lowerCamelCase    :						Optional[int]						      =   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"			)

													__lowerCamelCase    :						Optional[int]						      =   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!"			)
																																		__lowerCamelCase    :						Union[str, Any]						      =   token_index
																											writer.write(" ".join(__UpperCAmelCase			) + "\n"			)
																											index += 1

													return vocab_file, merge_file






						def 					lowerCamelCase__   (				self					:	Union[str, Any]							,    UpperCAmelCase					:	Optional[int]							,    UpperCAmelCase					:	Tuple = None			):

													if token_ids_a is None:
																				return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
													__lowerCamelCase    :						List[str]						      =   [self.cls_token_id]
													__lowerCamelCase    :						str						      =   [self.sep_token_id]
													return cls + token_ids_a + sep + sep + token_ids_a + sep






						def 					lowerCamelCase__   (				self					:	Tuple							,    UpperCAmelCase					:	Dict							,    UpperCAmelCase					:	Optional[int] = None							,    UpperCAmelCase					:	Optional[int] = 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 					lowerCamelCase__   (				self					:	Optional[Any]							,    UpperCAmelCase					:	List[Any]							,    UpperCAmelCase					:	Dict = None			):
													__lowerCamelCase    :						Optional[Any]						      =   [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 + sep + token_ids_a + sep			) * [0]







						def 					lowerCamelCase__   (				self					:	Tuple							,    UpperCAmelCase					:	int							,    UpperCAmelCase					:	str=False							,    **UpperCAmelCase					:	Any			):
													__lowerCamelCase    :						int						      =   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()):
																				__lowerCamelCase    :						Any						      =   ' ' + text
													return (text, kwargs)






"""simple docstring"""





import math
def  __A   (_SCREAMING_SNAKE_CASE			)					->int:





  """simple docstring"""


  if not isinstance(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			):
    lowerCAmelCase__			:Dict											=							F"Input value of [number={number}] must be an integer"
    raise TypeError(_SCREAMING_SNAKE_CASE			)

  if number < 1:
    lowerCAmelCase__			:Dict											=							F"Input value of [number={number}] must be > 0"
    raise ValueError(_SCREAMING_SNAKE_CASE			)
  elif number == 1:
    return 3
  elif number == 2:
    return 5
  else:
    lowerCAmelCase__			:Union[str, Any]											=							int(math.log(number // 3     ,   2			)			) + 2

    lowerCAmelCase__			:Optional[Any]											=							[3, 5]
    lowerCAmelCase__			:Optional[Any]											=							2
    lowerCAmelCase__			:List[str]											=							3
    for block in range(1     ,   _SCREAMING_SNAKE_CASE			):
      for _ in range(_SCREAMING_SNAKE_CASE			):
        proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1]			)
        proth_index += 1
      increment *= 2

  return proth_list[number - 1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  for number in range(11):
    __A											=		0
    try:
      __A											=		proth(number)
    except ValueError:
      print(F'''ValueError: there is no {number}th Proth number''')
      continue

    print(F'''The {number}th Proth number: {value}''')
