'''simple docstring'''





import os
import unittest

from transformers import RealmTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.models.realm.tokenization_realm import RealmTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class    UpperCamelCase (    lowerCAmelCase__  ,			unittest.TestCase    ):







    """simple docstring"""





    A			:  List[Any]            =       RealmTokenizer
    A			:  Dict            =       RealmTokenizerFast
    A			:  int            =       True
    A			:  Any            =       True
    A			:  Optional[int]            =       filter_non_english





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







         super().setUp()

         a :				List[Any]				=      [
             '[UNK]',
             '[CLS]',
             '[SEP]',
             '[PAD]',
             '[MASK]',
             'want',
             '##want',
             '##ed',
             'wa',
             'un',
             'runn',
             '##ing',
             ',',
             'low',
             'lowest',
         ]
         a :				Tuple				=      os.path.join(self.tmpdirname				,				VOCAB_FILES_NAMES['vocab_file'])
         with open(self.vocab_file				,				'w'				,				encoding='utf-8') as vocab_writer:
              vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]))





    def 					SCREAMING_SNAKE_CASE_			( self			:		Any				,				UpperCAmelCase_			:		Any):


         """simple docstring"""







         a :				Dict				=      'UNwant\u00E9d,running'
         a :				Tuple				=      'unwanted, running'
         return input_text, output_text





    def 					SCREAMING_SNAKE_CASE_			( self			:		Dict):


         """simple docstring"""







         a :				int				=      self.tokenizer_class(self.vocab_file)

         a :				Optional[int]				=      tokenizer.tokenize('UNwant\u00E9d,running')
         self.assertListEqual(a__				,				['un', '##want', '##ed', ',', 'runn', '##ing'])
         self.assertListEqual(tokenizer.convert_tokens_to_ids(a__)				,				[9, 6, 7, 1_2, 1_0, 1_1])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Dict):


         """simple docstring"""







         if not self.test_rust_tokenizer:
              return

         a :				Tuple				=      self.get_tokenizer()
         a :				Optional[int]				=      self.get_rust_tokenizer()

         a :				List[Any]				=      'UNwant\u00E9d,running'

         a :				int				=      tokenizer.tokenize(a__)
         a :				int				=      rust_tokenizer.tokenize(a__)
         self.assertListEqual(a__				,				a__)

         a :				Any				=      tokenizer.encode(a__				,				add_special_tokens=a__)
         a :				Tuple				=      rust_tokenizer.encode(a__				,				add_special_tokens=a__)
         self.assertListEqual(a__				,				a__)

         a :				str				=      self.get_rust_tokenizer()
         a :				Union[str, Any]				=      tokenizer.encode(a__)
         a :				int				=      rust_tokenizer.encode(a__)
         self.assertListEqual(a__				,				a__)

         # With lower casing
         a :				List[str]				=      self.get_tokenizer(do_lower_case=a__)
         a :				str				=      self.get_rust_tokenizer(do_lower_case=a__)

         a :				int				=      'UNwant\u00E9d,running'

         a :				Optional[int]				=      tokenizer.tokenize(a__)
         a :				List[str]				=      rust_tokenizer.tokenize(a__)
         self.assertListEqual(a__				,				a__)

         a :				Tuple				=      tokenizer.encode(a__				,				add_special_tokens=a__)
         a :				Dict				=      rust_tokenizer.encode(a__				,				add_special_tokens=a__)
         self.assertListEqual(a__				,				a__)

         a :				Union[str, Any]				=      self.get_rust_tokenizer()
         a :				Optional[int]				=      tokenizer.encode(a__)
         a :				List[str]				=      rust_tokenizer.encode(a__)
         self.assertListEqual(a__				,				a__)





    def 					SCREAMING_SNAKE_CASE_			( self			:		Any):


         """simple docstring"""







         a :				Union[str, Any]				=      BasicTokenizer()

         self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz')				,				['ah', '\u535A', '\u63A8', 'zz'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Dict):


         """simple docstring"""







         a :				str				=      BasicTokenizer(do_lower_case=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  ')				,				['hello', '!', 'how', 'are', 'you', '?'])
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo')				,				['hello'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		str):


         """simple docstring"""







         a :				Optional[Any]				=      BasicTokenizer(do_lower_case=a__				,				strip_accents=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')				,				['hällo', '!', 'how', 'are', 'you', '?'])
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo')				,				['h\u00E9llo'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







         a :				str				=      BasicTokenizer(do_lower_case=a__				,				strip_accents=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')				,				['hallo', '!', 'how', 'are', 'you', '?'])
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo')				,				['hello'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Tuple):


         """simple docstring"""







         a :				Dict				=      BasicTokenizer(do_lower_case=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')				,				['hallo', '!', 'how', 'are', 'you', '?'])
         self.assertListEqual(tokenizer.tokenize('H\u00E9llo')				,				['hello'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Union[str, Any]):


         """simple docstring"""







         a :				List[str]				=      BasicTokenizer(do_lower_case=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  ')				,				['HeLLo', '!', 'how', 'Are', 'yoU', '?'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Dict):


         """simple docstring"""







         a :				Optional[int]				=      BasicTokenizer(do_lower_case=a__				,				strip_accents=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')				,				['HäLLo', '!', 'how', 'Are', 'yoU', '?'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Any):


         """simple docstring"""







         a :				int				=      BasicTokenizer(do_lower_case=a__				,				strip_accents=a__)

         self.assertListEqual(
             tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')				,				['HaLLo', '!', 'how', 'Are', 'yoU', '?'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		int):


         """simple docstring"""







         a :				str				=      BasicTokenizer(do_lower_case=a__				,				never_split=['[UNK]'])

         self.assertListEqual(
             tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]')				,				['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Dict):


         """simple docstring"""







         a :				int				=      ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

         a :				Tuple				=      {}
         for i, token in enumerate(a__):
              a :				Union[str, Any]				=      i
         a :				List[Any]				=      WordpieceTokenizer(vocab=a__				,				unk_token='[UNK]')

         self.assertListEqual(tokenizer.tokenize('')				,				[])

         self.assertListEqual(tokenizer.tokenize('unwanted running')				,				['un', '##want', '##ed', 'runn', '##ing'])

         self.assertListEqual(tokenizer.tokenize('unwantedX running')				,				['[UNK]', 'runn', '##ing'])





    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[Any]):


         """simple docstring"""







         self.assertTrue(_is_whitespace(' '))
         self.assertTrue(_is_whitespace('\t'))
         self.assertTrue(_is_whitespace('\r'))
         self.assertTrue(_is_whitespace('\n'))
         self.assertTrue(_is_whitespace('\u00A0'))

         self.assertFalse(_is_whitespace('A'))
         self.assertFalse(_is_whitespace('-'))





    def 					SCREAMING_SNAKE_CASE_			( self			:		List[str]):


         """simple docstring"""







         self.assertTrue(_is_control('\u0005'))

         self.assertFalse(_is_control('A'))
         self.assertFalse(_is_control(' '))
         self.assertFalse(_is_control('\t'))
         self.assertFalse(_is_control('\r'))





    def 					SCREAMING_SNAKE_CASE_			( self			:		int):


         """simple docstring"""







         self.assertTrue(_is_punctuation('-'))
         self.assertTrue(_is_punctuation('$'))
         self.assertTrue(_is_punctuation('`'))
         self.assertTrue(_is_punctuation('.'))

         self.assertFalse(_is_punctuation('A'))
         self.assertFalse(_is_punctuation(' '))





    def 					SCREAMING_SNAKE_CASE_			( self			:		int):


         """simple docstring"""







         a :				Dict				=      self.get_tokenizer()

         # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
         self.assertListEqual([tokenizer.tokenize(a__) for t in ['Test', '\xad', 'test']]				,				[['[UNK]'], [], ['[UNK]']])

         if self.test_rust_tokenizer:
              a :				int				=      self.get_rust_tokenizer()
              self.assertListEqual(
                  [rust_tokenizer.tokenize(a__) for t in ['Test', '\xad', 'test']]				,				[['[UNK]'], [], ['[UNK]']])





    @slow
    def 					SCREAMING_SNAKE_CASE_			( self			:		int):


         """simple docstring"""







         a :				Union[str, Any]				=      self.tokenizer_class.from_pretrained('bert-base-uncased')

         a :				Optional[int]				=      tokenizer.encode('sequence builders'				,				add_special_tokens=a__)
         a :				Optional[int]				=      tokenizer.encode('multi-sequence build'				,				add_special_tokens=a__)

         a :				int				=      tokenizer.build_inputs_with_special_tokens(a__)
         a :				List[str]				=      tokenizer.build_inputs_with_special_tokens(a__				,				a__)

         assert encoded_sentence == [1_0_1] + text + [1_0_2]
         assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]





    def 					SCREAMING_SNAKE_CASE_			( self			:		Tuple):


         """simple docstring"""







         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""):
                   a :				int				=      self.rust_tokenizer_class.from_pretrained(a__				,				**a__)

                   a :				List[Any]				=      f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
                   a :				Dict				=      tokenizer_r.encode_plus(
                       a__				,				return_attention_mask=a__				,				return_token_type_ids=a__				,				return_offsets_mapping=a__				,				add_special_tokens=a__				,				)

                   a :				Any				=      tokenizer_r.do_lower_case if hasattr(a__				,				'do_lower_case') else False
                   a :				Tuple				=      (
                       [
                           ((0, 0), tokenizer_r.cls_token),
                           ((0, 1), 'A'),
                           ((1, 2), ','),
                           ((3, 5), 'na'),
                           ((5, 6), '##ï'),
                           ((6, 8), '##ve'),
                           ((9, 1_5), tokenizer_r.mask_token),
                           ((1_6, 2_1), 'Allen'),
                           ((2_1, 2_3), '##NL'),
                           ((2_3, 2_4), '##P'),
                           ((2_5, 3_3), 'sentence'),
                           ((3_3, 3_4), '.'),
                           ((0, 0), tokenizer_r.sep_token),
                       ]
                       if not do_lower_case
                       else [
                           ((0, 0), tokenizer_r.cls_token),
                           ((0, 1), 'a'),
                           ((1, 2), ','),
                           ((3, 8), 'naive'),
                           ((9, 1_5), tokenizer_r.mask_token),
                           ((1_6, 2_1), 'allen'),
                           ((2_1, 2_3), '##nl'),
                           ((2_3, 2_4), '##p'),
                           ((2_5, 3_3), 'sentence'),
                           ((3_3, 3_4), '.'),
                           ((0, 0), tokenizer_r.sep_token),
                       ]
                   )

                   self.assertEqual(
                       [e[1] for e in expected_results]				,				tokenizer_r.convert_ids_to_tokens(tokens['input_ids']))
                   self.assertEqual([e[0] for e in expected_results]				,				tokens['offset_mapping'])







    @slow
    def 					SCREAMING_SNAKE_CASE_			( self			:		Optional[int]):


         """simple docstring"""







         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""):
                   a :				Dict				=      self.rust_tokenizer_class.from_pretrained(a__				,				**a__)
                   a :				Optional[int]				=      self.tokenizer_class.from_pretrained(a__				,				**a__)
                   a :				Any				=      [['Hello world!', 'Nice to meet you!'], ['The cute cat.', 'The adorable dog.']]

                   a :				List[str]				=      tokenizer_r.batch_encode_candidates(a__				,				max_length=1_0				,				return_tensors='np')
                   a :				List[str]				=      tokenizer_p.batch_encode_candidates(a__				,				max_length=1_0				,				return_tensors='np')

                   a :				Optional[int]				=      (2, 2, 1_0)

                   self.assertEqual(encoded_sentence_r['input_ids'].shape				,				a__)
                   self.assertEqual(encoded_sentence_r['attention_mask'].shape				,				a__)
                   self.assertEqual(encoded_sentence_r['token_type_ids'].shape				,				a__)

                   self.assertEqual(encoded_sentence_p['input_ids'].shape				,				a__)
                   self.assertEqual(encoded_sentence_p['attention_mask'].shape				,				a__)
                   self.assertEqual(encoded_sentence_p['token_type_ids'].shape				,				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())






