






import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


A__			:    List[str]         =				'▁'

A__			:    Tuple         =				{'vocab_file': 'spiece.model'}

A__			:    Dict         =				{
    'vocab_file': {'google/pegasus-xsum': 'https://huggingface.co/google/pegasus-xsum/resolve/main/spiece.model'}
}

A__			:    List[Any]         =				{
    'google/pegasus-xsum': 5_12,
}


A__			:    int         =				logging.get_logger(__name__)
class    _UpperCAmelCase      ( A__			):

				"""simple docstring"""




				lowercase__       							= VOCAB_FILES_NAMES

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




				def __init__(  self		:					Dict,						lowerCamelCase		:					Any,						lowerCamelCase		:					List[str]="<pad>",						lowerCamelCase		:					Optional[Any]="</s>",						lowerCamelCase		:					int="<unk>",						lowerCamelCase		:					Optional[int]="<mask_2>",						lowerCamelCase		:					Tuple="<mask_1>",						lowerCamelCase		:					Any=None,						lowerCamelCase		:					Optional[int]=103,						lowerCamelCase		:					Optional[Dict[str, Any]] = None,						**lowerCamelCase		:					Tuple,						):

								'''simple docstring'''
								lowercase__     				=    offset
								if additional_special_tokens is not None:
												if not isinstance(lowerCamelCase,						lowerCamelCase						):
																raise TypeError(
																    F"""additional_special_tokens should be of type {type(lowerCamelCase						)}, but is"""
																    F""" {type(lowerCamelCase						)}"""						)

												lowercase__     				=    (
												    ([mask_token_sent] + additional_special_tokens)
												    if mask_token_sent not in additional_special_tokens and mask_token_sent is not None
												    else additional_special_tokens
												)
												# fill additional tokens with ..., <unk_token_102> in case not all additional tokens are already taken
												additional_special_tokens_extended += [
												    F"""<unk_{i}>""" for i in range(len(lowerCamelCase						),						self.offset - 1						)
												]

												if len(set(lowerCamelCase						)						) != len(lowerCamelCase						):
																raise ValueError(
																    '''Please make sure that the provided additional_special_tokens do not contain an incorrectly'''
																    F""" shifted list of <unk_x> tokens. Found {additional_special_tokens_extended}."""						)
												lowercase__     				=    additional_special_tokens_extended
								else:
												lowercase__     				=    [mask_token_sent] if mask_token_sent is not None else []
												additional_special_tokens += [F"""<unk_{i}>""" for i in range(2,						self.offset						)]

								lowercase__     				=    {} if sp_model_kwargs is None else sp_model_kwargs

								super().__init__(
								    eos_token=lowerCamelCase,						unk_token=lowerCamelCase,						mask_token=lowerCamelCase,						pad_token=lowerCamelCase,						mask_token_sent=lowerCamelCase,						offset=lowerCamelCase,						additional_special_tokens=lowerCamelCase,						sp_model_kwargs=self.sp_model_kwargs,						**lowerCamelCase,						)
								lowercase__     				=    mask_token_sent
								lowercase__     				=    vocab_file
								lowercase__     				=    spm.SentencePieceProcessor(**self.sp_model_kwargs						)
								self.sp_model.Load(lowerCamelCase						)

								# add special tokens to encoder dict
								lowercase__     				=    {
								    0: self.pad_token,
								    1: self.eos_token,
								}

								if self.mask_token_sent is not None:
												self.encoder.update(
												    {
												        2: self.mask_token_sent,
												        3: self.mask_token,
												    }						)

								if self.offset > 0:
												# entries 2-104 are only used for pretraining and called <mask_1>, <mask_2>, unk_2, ...unk_102
												# mask_token_sent is already added to list -> so start at 1
												self.encoder.update({i + 3: additional_special_tokens[i] for i in range(1,						self.offset - 1						)}						)

								lowercase__     				=    {v: k for k, v in self.encoder.items()}




				@property
				def        lowercase__     (  self		:					Union[str, Any]						):

								'''simple docstring'''
								return len(self.sp_model						) + self.offset




				def        lowercase__     (  self		:					Dict						):

								'''simple docstring'''
								lowercase__     				=    {self.convert_ids_to_tokens(lowerCamelCase						): i for i in range(self.vocab_size						)}
								vocab.update(self.added_tokens_encoder						)
								return vocab




				def __getstate__(  self		:					Tuple						):

								'''simple docstring'''
								lowercase__     				=    self.__dict__.copy()
								lowercase__     				=    None
								return state




				def __setstate__(  self		:					List[Any],						lowerCamelCase		:					Dict						):

								'''simple docstring'''
								lowercase__     				=    d

								# for backward compatibility
								if not hasattr(self,						'''sp_model_kwargs'''						):
												lowercase__     				=    {}

								lowercase__     				=    spm.SentencePieceProcessor(**self.sp_model_kwargs						)
								self.sp_model.Load(self.vocab_file						)




				def        lowercase__     (  self		:					int,						lowerCamelCase		:					str						):

								'''simple docstring'''
								return self.sp_model.encode(lowerCamelCase,						out_type=lowerCamelCase						)




				def        lowercase__     (  self		:					List[str],						lowerCamelCase		:					str						):

								'''simple docstring'''
								if token in self.decoder:
												return self.decoder[token]
								elif token in self.added_tokens_decoder:
												return self.added_tokens_decoder[token]
								lowercase__     				=    self.sp_model.piece_to_id(lowerCamelCase						)
								return sp_id + self.offset




				def        lowercase__     (  self		:					Any,						lowerCamelCase		:					int						):

								'''simple docstring'''
								if index in self.encoder:
												return self.encoder[index]
								elif index in self.added_tokens_encoder:
												return self.added_tokens_encoder[index]
								else:
												lowercase__     				=    self.sp_model.IdToPiece(index - self.offset						)
								return token




				def        lowercase__     (  self		:					int,						lowerCamelCase		:					List[Any]						):

								'''simple docstring'''
								lowercase__     				=    []
								lowercase__     				=    ''''''
								for token in tokens:
												# make sure that special tokens are not decoded using sentencepiece model
												if token in self.all_special_tokens:
																out_string += self.sp_model.decode(lowerCamelCase						) + token
																lowercase__     				=    []
												else:
																current_sub_tokens.append(lowerCamelCase						)
								out_string += self.sp_model.decode(lowerCamelCase						)
								return out_string.strip()




				def        lowercase__     (  self		:					str,						lowerCamelCase		:					Dict=False						):

								'''simple docstring'''
								return 1




				def        lowercase__     (  self		:					Tuple,						lowerCamelCase		:					Optional[Any]						):

								'''simple docstring'''
								lowercase__     				=    set(self.all_special_ids						)  # call it once instead of inside list comp
								all_special_ids.remove(self.unk_token_id						)  # <unk> is only sometimes special

								return [1 if x in all_special_ids else 0 for x in seq]




				def        lowercase__     (  self		:					Optional[Any],						lowerCamelCase		:					List,						lowerCamelCase		:					Optional[List] = None,						lowerCamelCase		:					bool = False						):

								'''simple docstring'''
								if already_has_special_tokens:
												return self._special_token_mask(lowerCamelCase						)
								elif token_ids_a is None:
												return self._special_token_mask(lowerCamelCase						) + [1]
								else:
												return self._special_token_mask(token_ids_a + token_ids_a						) + [1]




				def        lowercase__     (  self		:					Optional[int],						lowerCamelCase		:					Optional[int],						lowerCamelCase		:					Dict=None						):

								'''simple docstring'''
								if token_ids_a is None:
												return token_ids_a + [self.eos_token_id]
								# We don't expect to process pairs, but leave the pair logic for API consistency
								return token_ids_a + token_ids_a + [self.eos_token_id]




				def        lowercase__     (  self		:					Union[str, Any],						lowerCamelCase		:					str,						lowerCamelCase		:					Optional[str] = None						):

								'''simple docstring'''
								if not os.path.isdir(lowerCamelCase						):
												logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""						)
												return
								lowercase__     				=    os.path.join(
								    lowerCamelCase,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']						)

								if os.path.abspath(self.vocab_file						) != os.path.abspath(lowerCamelCase						) and os.path.isfile(self.vocab_file						):
												copyfile(self.vocab_file,						lowerCamelCase						)
								elif not os.path.isfile(self.vocab_file						):
												with open(lowerCamelCase,						'''wb'''						) as fi:
																lowercase__     				=    self.sp_model.serialized_model_proto()
																fi.write(lowerCamelCase						)

								return (out_vocab_file,)












from functools import reduce

A__			:    Union[str, Any]         =				(
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)






def 						a    (		lowerCamelCase_ = N       ):






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


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




