

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


_SCREAMING_SNAKE_CASE					:  Any             =      logging.get_logger(__name__)


_SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt'''}

# See all BART models at https://huggingface.co/models?filter=bart
_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      {
    '''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''',
    },
}

_SCREAMING_SNAKE_CASE					:  List[Any]             =      {
    '''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     UpperCAmelCase_       (						):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   (
         list(range(ord('''!'''    )				,		ord('''~'''    ) + 1    )    ) + list(range(ord('''¡'''    )				,		ord('''¬'''    ) + 1    )    ) + list(range(ord('''®'''    )				,		ord('''ÿ'''    ) + 1    )    )
     )
     SCREAMING_SNAKE_CASE__   =   bs[:]
     SCREAMING_SNAKE_CASE__   =   0
     for b in range(2**8    ):
          if b not in bs:
               bs.append(_A    )
               cs.append(2**8 + n    )
               n += 1
     SCREAMING_SNAKE_CASE__   =   [chr(_A    ) for n in cs]
     return dict(zip(_A				,		_A    )    )
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   set()
     SCREAMING_SNAKE_CASE__   =   word[0]
     for char in word[1:]:
          pairs.add((prev_char, char)    )
          SCREAMING_SNAKE_CASE__   =   char
     return pairs







class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  a									= VOCAB_FILES_NAMES
  a									= PRETRAINED_VOCAB_FILES_MAP
  a									= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a									= ["input_ids", "attention_mask"]






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

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

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

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

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






  @property
  def 				lowercase_		(							self						:		Any )		->							int:
       return len(self.encoder )






  def 				lowercase_		(							self						:		List[str] )		->							str:
       return dict(self.encoder     ,       **self.added_tokens_encoder )






  def 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		int )		->							Dict:
       if token in self.cache:
            return self.cache[token]
       SCREAMING_SNAKE_CASE__   =   tuple(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   get_pairs(__lowerCamelCase )

       if not pairs:
            return token

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

                 if word[i] == first and i < len(__lowerCamelCase ) - 1 and word[i + 1] == second:
                      new_word.append(first + second )
                      i += 2
                 else:
                      new_word.append(word[i] )
                      i += 1
            SCREAMING_SNAKE_CASE__   =   tuple(__lowerCamelCase )
            SCREAMING_SNAKE_CASE__   =   new_word
            if len(__lowerCamelCase ) == 1:
                 break
            else:
                 SCREAMING_SNAKE_CASE__   =   get_pairs(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   ''' '''.join(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   word
       return word






  def 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Optional[int] )		->							Tuple:
       SCREAMING_SNAKE_CASE__   =   []
       for token in re.findall(self.pat     ,       __lowerCamelCase ):
            SCREAMING_SNAKE_CASE__   =   ''''''.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(__lowerCamelCase ).split(''' ''' ) )
       return bpe_tokens






  def 				lowercase_		(							self						:		int     ,       __lowerCamelCase						:		Any )		->							List[str]:
       return self.encoder.get(__lowerCamelCase     ,       self.encoder.get(self.unk_token ) )






  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		str )		->							Optional[int]:
       return self.decoder.get(__lowerCamelCase )






  def 				lowercase_		(							self						:		Any     ,       __lowerCamelCase						:		Tuple )		->							List[Any]:
       SCREAMING_SNAKE_CASE__   =   ''''''.join(__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   bytearray([self.byte_decoder[c] for c in text] ).decode('''utf-8'''     ,       errors=self.errors )
       return text






  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Optional[str] = None )		->							Tuple[str]:
       if not os.path.isdir(__lowerCamelCase ):
            logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
            return
       SCREAMING_SNAKE_CASE__   =   os.path.join(
           __lowerCamelCase     ,       (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file'''] )
       SCREAMING_SNAKE_CASE__   =   os.path.join(
           __lowerCamelCase     ,       (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file'''] )

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

       SCREAMING_SNAKE_CASE__   =   0
       with open(__lowerCamelCase     ,       '''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 __lowerCamelCase : 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!''' )
                      SCREAMING_SNAKE_CASE__   =   token_index
                 writer.write(''' '''.join(__lowerCamelCase ) + '''\n''' )
                 index += 1

       return vocab_file, merge_file






  def 				lowercase_		(							self						:		int     ,       __lowerCamelCase						:		List[int]     ,       __lowerCamelCase						:		Optional[List[int]] = None )		->							List[int]:
       if token_ids_a is None:
            return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
       SCREAMING_SNAKE_CASE__   =   [self.cls_token_id]
       SCREAMING_SNAKE_CASE__   =   [self.sep_token_id]
       return cls + token_ids_a + sep + sep + token_ids_a + sep






  def 				lowercase_		(							self						:		List[str]     ,       __lowerCamelCase						:		List[int]     ,       __lowerCamelCase						:		Optional[List[int]] = None     ,       __lowerCamelCase						:		bool = False )		->							List[int]:
       if already_has_special_tokens:
            return super().get_special_tokens_mask(
                token_ids_a=__lowerCamelCase     ,       token_ids_a=__lowerCamelCase     ,       already_has_special_tokens=__lowerCamelCase )

       if token_ids_a is None:
            return [1] + ([0] * len(__lowerCamelCase )) + [1]
       return [1] + ([0] * len(__lowerCamelCase )) + [1, 1] + ([0] * len(__lowerCamelCase )) + [1]






  def 				lowercase_		(							self						:		List[Any]     ,       __lowerCamelCase						:		List[int]     ,       __lowerCamelCase						:		Optional[List[int]] = None )		->							List[int]:
       SCREAMING_SNAKE_CASE__   =   [self.sep_token_id]
       SCREAMING_SNAKE_CASE__   =   [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 				lowercase_		(							self						:		Union[str, Any]     ,       __lowerCamelCase						:		Any     ,       __lowerCamelCase						:		Union[str, Any]=False     ,       **__lowerCamelCase						:		List[str] )		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   kwargs.pop('''add_prefix_space'''     ,       self.add_prefix_space )
       if (is_split_into_words or add_prefix_space) and (len(__lowerCamelCase ) > 0 and not text[0].isspace()):
            SCREAMING_SNAKE_CASE__   =   ''' ''' + text
       return (text, kwargs)





from functools import reduce

_SCREAMING_SNAKE_CASE					:  Any             =      (
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)
def     UpperCAmelCase_       (						_A = N    ):





     '''simple docstring'''




     return max(
         # mypy cannot properly interpret reduce
         int(reduce(lambda _A				,		_A    : str(int(_A    ) * int(_A    )    )				,		n[i : i + 13]    )    )
         for i in range(len(_A    ) - 12    )    )


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


