



import os
import unittest

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    BertTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class 							lowerCAmelCase_						(    _snake_case			,       unittest.TestCase				):
       UpperCAmelCase__							:   str  	=    BertTokenizer
       UpperCAmelCase__							:   Tuple  	=    BertTokenizerFast
       UpperCAmelCase__							:   List[str]  	=    True
       UpperCAmelCase__							:   Tuple  	=    True
       UpperCAmelCase__							:   Optional[Any]  	=    filter_non_english
       def    snake_case_			(     self			)	->						List[str]:
          super().setUp()

          UpperCamelCase       :    Dict		      =      [
              '''[UNK]''',
              '''[CLS]''',
              '''[SEP]''',
              '''[PAD]''',
              '''[MASK]''',
              '''want''',
              '''##want''',
              '''##ed''',
              '''wa''',
              '''un''',
              '''runn''',
              '''##ing''',
              ''',''',
              '''low''',
              '''lowest''',
          ]
          UpperCamelCase       :    List[str]		      =      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    snake_case_			(     self,     SCREAMING_SNAKE_CASE_			)	->						Optional[Any]:
          UpperCamelCase       :    List[str]		      =      '''UNwant\u00E9d,running'''
          UpperCamelCase       :    int		      =      '''unwanted, running'''
          return input_text, output_text
       def    snake_case_			(     self			)	->						int:
          UpperCamelCase       :    Tuple		      =      self.tokenizer_class(self.vocab_file			)

          UpperCamelCase       :    Tuple		      =      tokenizer.tokenize('UNwant\u00E9d,running'			)
          self.assertListEqual(__lowerCamelCase,     ['un', '##want', '##ed', ',', 'runn', '##ing']			)
          self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCamelCase			),     [9, 6, 7, 12, 10, 11]			)
       def    snake_case_			(     self			)	->						str:
          if not self.test_rust_tokenizer:
             return

          UpperCamelCase       :    List[Any]		      =      self.get_tokenizer()
          UpperCamelCase       :    Tuple		      =      self.get_rust_tokenizer()

          UpperCamelCase       :    str		      =      '''UNwant\u00E9d,running'''

          UpperCamelCase       :    Dict		      =      tokenizer.tokenize(__lowerCamelCase			)
          UpperCamelCase       :    Union[str, Any]		      =      rust_tokenizer.tokenize(__lowerCamelCase			)
          self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)

          UpperCamelCase       :    int		      =      tokenizer.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)
          UpperCamelCase       :    Optional[int]		      =      rust_tokenizer.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)
          self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)

          UpperCamelCase       :    Tuple		      =      self.get_rust_tokenizer()
          UpperCamelCase       :    List[Any]		      =      tokenizer.encode(__lowerCamelCase			)
          UpperCamelCase       :    List[Any]		      =      rust_tokenizer.encode(__lowerCamelCase			)
          self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)

          # With lower casing
          UpperCamelCase       :    Tuple		      =      self.get_tokenizer(do_lower_case=__lowerCamelCase			)
          UpperCamelCase       :    Dict		      =      self.get_rust_tokenizer(do_lower_case=__lowerCamelCase			)

          UpperCamelCase       :    Optional[Any]		      =      '''UNwant\u00E9d,running'''

          UpperCamelCase       :    int		      =      tokenizer.tokenize(__lowerCamelCase			)
          UpperCamelCase       :    Tuple		      =      rust_tokenizer.tokenize(__lowerCamelCase			)
          self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)

          UpperCamelCase       :    str		      =      tokenizer.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)
          UpperCamelCase       :    str		      =      rust_tokenizer.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)
          self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)

          UpperCamelCase       :    Union[str, Any]		      =      self.get_rust_tokenizer()
          UpperCamelCase       :    Dict		      =      tokenizer.encode(__lowerCamelCase			)
          UpperCamelCase       :    Optional[Any]		      =      rust_tokenizer.encode(__lowerCamelCase			)
          self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)
       def    snake_case_			(     self			)	->						List[Any]:
          UpperCamelCase       :    Any		      =      BasicTokenizer()

          self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'			),     ['ah', '\u535A', '\u63A8', 'zz']			)
       def    snake_case_			(     self			)	->						Optional[Any]:
          UpperCamelCase       :    List[Any]		      =      BasicTokenizer(do_lower_case=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '			),     ['hello', '!', 'how', 'are', 'you', '?']			)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'			),     ['hello']			)
       def    snake_case_			(     self			)	->						List[str]:
          UpperCamelCase       :    Any		      =      BasicTokenizer(do_lower_case=__lowerCamelCase,     strip_accents=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '			),     ['hällo', '!', 'how', 'are', 'you', '?']			)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'			),     ['h\u00E9llo']			)
       def    snake_case_			(     self			)	->						str:
          UpperCamelCase       :    List[str]		      =      BasicTokenizer(do_lower_case=__lowerCamelCase,     strip_accents=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '			),     ['hallo', '!', 'how', 'are', 'you', '?']			)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'			),     ['hello']			)
       def    snake_case_			(     self			)	->						int:
          UpperCamelCase       :    Dict		      =      BasicTokenizer(do_lower_case=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '			),     ['hallo', '!', 'how', 'are', 'you', '?']			)
          self.assertListEqual(tokenizer.tokenize('H\u00E9llo'			),     ['hello']			)
       def    snake_case_			(     self			)	->						Any:
          UpperCamelCase       :    Optional[Any]		      =      BasicTokenizer(do_lower_case=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '			),     ['HeLLo', '!', 'how', 'Are', 'yoU', '?']			)
       def    snake_case_			(     self			)	->						Tuple:
          UpperCamelCase       :    Any		      =      BasicTokenizer(do_lower_case=__lowerCamelCase,     strip_accents=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '			),     ['HäLLo', '!', 'how', 'Are', 'yoU', '?']			)
       def    snake_case_			(     self			)	->						List[str]:
          UpperCamelCase       :    List[Any]		      =      BasicTokenizer(do_lower_case=__lowerCamelCase,     strip_accents=__lowerCamelCase			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '			),     ['HaLLo', '!', 'how', 'Are', 'yoU', '?']			)
       def    snake_case_			(     self			)	->						List[str]:
          UpperCamelCase       :    List[Any]		      =      BasicTokenizer(do_lower_case=__lowerCamelCase,     never_split=['[UNK]']			)

          self.assertListEqual(
              tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'			),     ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']			)
       def    snake_case_			(     self			)	->						str:
          UpperCamelCase       :    Optional[int]		      =      BasicTokenizer()
          UpperCamelCase       :    Union[str, Any]		      =      '''a\n\'ll !!to?\'d of, can\'t.'''
          UpperCamelCase       :    Union[str, Any]		      =      ['''a''', '''\'''', '''ll''', '''!''', '''!''', '''to''', '''?''', '''\'''', '''d''', '''of''', ''',''', '''can''', '''\'''', '''t''', '''.''']
          self.assertListEqual(tokenizer.tokenize(__lowerCamelCase			),     __lowerCamelCase			)
       def    snake_case_			(     self			)	->						List[str]:
          UpperCamelCase       :    Optional[Any]		      =      ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''want''', '''##want''', '''##ed''', '''wa''', '''un''', '''runn''', '''##ing''']

          UpperCamelCase       :    Any		      =      {}
          for i, token in enumerate(__lowerCamelCase			):
             UpperCamelCase       :    Optional[int]		      =      i
          UpperCamelCase       :    str		      =      WordpieceTokenizer(vocab=__lowerCamelCase,     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    snake_case_			(     self			)	->						Union[str, Any]:
          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    snake_case_			(     self			)	->						str:
          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    snake_case_			(     self			)	->						List[str]:
          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    snake_case_			(     self			)	->						Any:
          UpperCamelCase       :    Any		      =      self.get_tokenizer()
          UpperCamelCase       :    Tuple		      =      self.get_rust_tokenizer()

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

          self.assertListEqual(
              [rust_tokenizer.tokenize(__lowerCamelCase			) for t in ['Test', '\xad', 'test']],     [['[UNK]'], [], ['[UNK]']]			)
       @slow
       def    snake_case_			(     self			)	->						Optional[int]:
          UpperCamelCase       :    str		      =      self.tokenizer_class.from_pretrained('bert-base-uncased'			)

          UpperCamelCase       :    int		      =      tokenizer.encode('sequence builders',     add_special_tokens=__lowerCamelCase			)
          UpperCamelCase       :    Dict		      =      tokenizer.encode('multi-sequence build',     add_special_tokens=__lowerCamelCase			)

          UpperCamelCase       :    int		      =      tokenizer.build_inputs_with_special_tokens(__lowerCamelCase			)
          UpperCamelCase       :    Tuple		      =      tokenizer.build_inputs_with_special_tokens(__lowerCamelCase,     __lowerCamelCase			)

          assert encoded_sentence == [101] + text + [102]
          assert encoded_pair == [101] + text + [102] + text_a + [102]
       def    snake_case_			(     self			)	->						int:
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
                UpperCamelCase       :    Any		      =      self.rust_tokenizer_class.from_pretrained(__lowerCamelCase,     **__lowerCamelCase			)

                UpperCamelCase       :    str		      =      F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
                UpperCamelCase       :    Dict		      =      tokenizer_r.encode_plus(
                    __lowerCamelCase,     return_attention_mask=__lowerCamelCase,     return_token_type_ids=__lowerCamelCase,     return_offsets_mapping=__lowerCamelCase,     add_special_tokens=__lowerCamelCase,     )

                UpperCamelCase       :    Dict		      =      tokenizer_r.do_lower_case if hasattr(__lowerCamelCase,     'do_lower_case'			) else False
                UpperCamelCase       :    Optional[Any]		      =      (
                    [
                        ((0, 0), tokenizer_r.cls_token),
                        ((0, 1), '''A'''),
                        ((1, 2), ''','''),
                        ((3, 5), '''na'''),
                        ((5, 6), '''##ï'''),
                        ((6, 8), '''##ve'''),
                        ((9, 15), tokenizer_r.mask_token),
                        ((16, 21), '''Allen'''),
                        ((21, 23), '''##NL'''),
                        ((23, 24), '''##P'''),
                        ((25, 33), '''sentence'''),
                        ((33, 34), '''.'''),
                        ((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, 15), tokenizer_r.mask_token),
                        ((16, 21), '''allen'''),
                        ((21, 23), '''##nl'''),
                        ((23, 24), '''##p'''),
                        ((25, 33), '''sentence'''),
                        ((33, 34), '''.'''),
                        ((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']			)






       def    snake_case_			(     self			)	->						int:
          UpperCamelCase       :    Optional[int]		      =      ['''的''', '''人''', '''有''']
          UpperCamelCase       :    str		      =      ''''''.join(__lowerCamelCase			)
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
                UpperCamelCase       :    Any		      =      True
                UpperCamelCase       :    int		      =      self.tokenizer_class.from_pretrained(__lowerCamelCase,     **__lowerCamelCase			)
                UpperCamelCase       :    int		      =      self.rust_tokenizer_class.from_pretrained(__lowerCamelCase,     **__lowerCamelCase			)

                UpperCamelCase       :    Optional[Any]		      =      tokenizer_p.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)
                UpperCamelCase       :    str		      =      tokenizer_r.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)

                UpperCamelCase       :    str		      =      tokenizer_r.convert_ids_to_tokens(__lowerCamelCase			)
                UpperCamelCase       :    Union[str, Any]		      =      tokenizer_p.convert_ids_to_tokens(__lowerCamelCase			)

                # it is expected that each Chinese character is not preceded by "##"
                self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)
                self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)

                UpperCamelCase       :    List[Any]		      =      False
                UpperCamelCase       :    Dict		      =      self.rust_tokenizer_class.from_pretrained(__lowerCamelCase,     **__lowerCamelCase			)
                UpperCamelCase       :    Dict		      =      self.tokenizer_class.from_pretrained(__lowerCamelCase,     **__lowerCamelCase			)

                UpperCamelCase       :    str		      =      tokenizer_r.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)
                UpperCamelCase       :    str		      =      tokenizer_p.encode(__lowerCamelCase,     add_special_tokens=__lowerCamelCase			)

                UpperCamelCase       :    int		      =      tokenizer_r.convert_ids_to_tokens(__lowerCamelCase			)
                UpperCamelCase       :    Dict		      =      tokenizer_p.convert_ids_to_tokens(__lowerCamelCase			)

                # it is expected that only the first Chinese character is not preceded by "##".
                UpperCamelCase       :    Tuple		      =      [
                    F"""##{token}""" if idx != 0 else token for idx, token in enumerate(__lowerCamelCase			)
                ]
                self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)
                self.assertListEqual(__lowerCamelCase,     __lowerCamelCase			)







'''simple docstring'''





from functools import reduce

__lowerCamelCase												=						(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)


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


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



