


'''simple docstring'''



import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_mpnet import MPNetTokenizer


_lowercase			:			Union[str, Any]	   =     logging.get_logger(__name__)

_lowercase			:			Any	   =     {"""vocab_file""": """vocab.txt""", """tokenizer_file""": """tokenizer.json"""}

_lowercase			:			Dict	   =     {
    """vocab_file""": {
        """microsoft/mpnet-base""": """https://huggingface.co/microsoft/mpnet-base/resolve/main/vocab.txt""",
    },
    """tokenizer_file""": {
        """microsoft/mpnet-base""": """https://huggingface.co/microsoft/mpnet-base/resolve/main/tokenizer.json""",
    },
}

_lowercase			:			List[str]	   =     {
    """microsoft/mpnet-base""": 512,
}

_lowercase			:			Dict	   =     {
    """microsoft/mpnet-base""": {"""do_lower_case""": True},
}






class        UpperCamelCase__(   lowerCAmelCase__       ):
				__magic_name__				:      int  		=       VOCAB_FILES_NAMES
				__magic_name__				:      Optional[int]  		=       PRETRAINED_VOCAB_FILES_MAP
				__magic_name__				:      Optional[int]  		=       PRETRAINED_INIT_CONFIGURATION
				__magic_name__				:      List[Any]  		=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				__magic_name__				:      str  		=       MPNetTokenizer
				__magic_name__				:      Any  		=       ["input_ids", "attention_mask"]




				def __init__(		self			: Optional[int]      ,    lowerCAmelCase			: str=None      ,    lowerCAmelCase			: Tuple=None      ,    lowerCAmelCase			: int=True      ,    lowerCAmelCase			: Union[str, Any]="<s>"      ,    lowerCAmelCase			: Any="</s>"      ,    lowerCAmelCase			: Tuple="</s>"      ,    lowerCAmelCase			: List[Any]="<s>"      ,    lowerCAmelCase			: int="[UNK]"      ,    lowerCAmelCase			: int="<pad>"      ,    lowerCAmelCase			: Optional[Any]="<mask>"      ,    lowerCAmelCase			: List[str]=True      ,    lowerCAmelCase			: Union[str, Any]=None      ,    **lowerCAmelCase			: Union[str, Any]      ,    )->     Any:

										"""simple docstring"""




										super().__init__(
										    a__      ,    tokenizer_file=a__      ,    do_lower_case=a__      ,    bos_token=a__      ,    eos_token=a__      ,    sep_token=a__      ,    cls_token=a__      ,    unk_token=a__      ,    pad_token=a__      ,    mask_token=a__      ,    tokenize_chinese_chars=a__      ,    strip_accents=a__      ,    **a__      ,    )

										UpperCAmelCase     				=	json.loads(self.backend_tokenizer.normalizer.__getstate__()      )
										if (
										    pre_tok_state.get('''lowercase'''      ,    a__      ) != do_lower_case
										    or pre_tok_state.get('''strip_accents'''      ,    a__      ) != strip_accents
										):
																UpperCAmelCase     				=	getattr(a__      ,    pre_tok_state.pop('''type'''      )      )
																UpperCAmelCase     				=	do_lower_case
																UpperCAmelCase     				=	strip_accents
																UpperCAmelCase     				=	pre_tok_class(**a__      )

										UpperCAmelCase     				=	do_lower_case




				@property
				def      a__(		self			: Optional[Any]      )->     Optional[Any]:

										"""simple docstring"""




										if self._mask_token is None:
																if self.verbose:
																						logger.error('''Using mask_token, but it is not set yet.'''      )
																return None
										return str(self._mask_token      )




				@mask_token.setter
				def      a__(		self			: int      ,    lowerCAmelCase			: Union[str, Any]      )->     Dict:

										"""simple docstring"""




										UpperCAmelCase     				=	AddedToken(a__      ,    lstrip=a__      ,    rstrip=a__      ) if isinstance(a__      ,    a__      ) else value
										UpperCAmelCase     				=	value




				def      a__(		self			: Optional[int]      ,    lowerCAmelCase			: Union[str, Any]      ,    lowerCAmelCase			: Any=None      )->     Dict:

										"""simple docstring"""




										UpperCAmelCase     				=	[self.bos_token_id] + token_ids_a + [self.eos_token_id]
										if token_ids_a is None:
																return output

										return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]




				def      a__(		self			: Tuple      ,    lowerCAmelCase			: Union[str, Any]      ,    lowerCAmelCase			: int = None      )->     Union[str, Any]:

										"""simple docstring"""




										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      a__(		self			: Any      ,    lowerCAmelCase			: List[str]      ,    lowerCAmelCase			: str = None      )->     Optional[Any]:

										"""simple docstring"""




										UpperCAmelCase     				=	self._tokenizer.model.save(a__      ,    name=a__      )
										return tuple(a__      )












"""simple docstring"""


A_     :      Dict								=1_0**8





def SCREAMING_SNAKE_CASE_   (       snake_case   :					int		)->		bool:
       if n % 10 == 0:
              return False
       _lowerCamelCase    	=					str(snake_case		)
       return s == s[::-1]





def SCREAMING_SNAKE_CASE_   (       )->		int:
       _lowerCamelCase    	=					set()
       _lowerCamelCase    	=					1
       _lowerCamelCase    	=					5
       while sum_squares < LIMIT:
              _lowerCamelCase    	=					first_square + 1
              while sum_squares < LIMIT:
                     if is_palindrome(snake_case		):
                            answer.add(snake_case		)
                     last_square += 1
                     sum_squares += last_square**2
              first_square += 1
              _lowerCamelCase    	=					first_square**2 + (first_square + 1) ** 2

       return sum(snake_case		)


if __name__ == "__main__":
      print(solution())






