





import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    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    (			UpperCAmelCase_							,    unittest.TestCase							):


  '''simple docstring'''
  a_							:       Any      					=MobileBertTokenizer
  a_							:       Any      					=MobileBertTokenizerFast
  a_							:       int      					=True
  a_							:       int      					=True
  a_							:       Dict      					=filter_non_english
  a_							:       Union[str, Any]      					='''google/mobilebert-uncased'''







  def UpperCamelCase_ (      self      :					Tuple							):


    '''simple docstring'''





    super().setUp()

    _snake_case   :				Optional[int]														=	[
        """[UNK]""",
        """[CLS]""",
        """[SEP]""",
        """[PAD]""",
        """[MASK]""",
        """want""",
        """##want""",
        """##ed""",
        """wa""",
        """un""",
        """runn""",
        """##ing""",
        """,""",
        """low""",
        """lowest""",
    ]
    _snake_case   :				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]							)							)

    _snake_case   :				Any														=	[
        (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
        for tokenizer_def in self.tokenizers_list
    ]







  def UpperCamelCase_ (      self      :					List[Any]      ,				UpperCamelCase      :					int							):


    '''simple docstring'''





    _snake_case   :				int														=	"""UNwant\u00E9d,running"""
    _snake_case   :				List[str]														=	"""unwanted, running"""
    return input_text, output_text







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	self.tokenizer_class(self.vocab_file							)

    _snake_case   :				str														=	tokenizer.tokenize('UNwant\u00E9d,running'							)
    self.assertListEqual(A__      ,				['un', '##want', '##ed', ',', 'runn', '##ing']							)
    self.assertListEqual(tokenizer.convert_tokens_to_ids(A__							)      ,				[9, 6, 7, 12, 10, 11]							)







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    if not self.test_rust_tokenizer:
      return

    _snake_case   :				List[str]														=	self.get_tokenizer()
    _snake_case   :				int														=	self.get_rust_tokenizer()

    _snake_case   :				Optional[Any]														=	"""UNwant\u00E9d,running"""

    _snake_case   :				Optional[Any]														=	tokenizer.tokenize(A__							)
    _snake_case   :				str														=	rust_tokenizer.tokenize(A__							)
    self.assertListEqual(A__      ,				A__							)

    _snake_case   :				List[str]														=	tokenizer.encode(A__      ,				add_special_tokens=A__							)
    _snake_case   :				Dict														=	rust_tokenizer.encode(A__      ,				add_special_tokens=A__							)
    self.assertListEqual(A__      ,				A__							)

    _snake_case   :				Optional[Any]														=	self.get_rust_tokenizer()
    _snake_case   :				Optional[Any]														=	tokenizer.encode(A__							)
    _snake_case   :				List[str]														=	rust_tokenizer.encode(A__							)
    self.assertListEqual(A__      ,				A__							)

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

    _snake_case   :				Dict														=	"""UNwant\u00E9d,running"""

    _snake_case   :				str														=	tokenizer.tokenize(A__							)
    _snake_case   :				int														=	rust_tokenizer.tokenize(A__							)
    self.assertListEqual(A__      ,				A__							)

    _snake_case   :				str														=	tokenizer.encode(A__      ,				add_special_tokens=A__							)
    _snake_case   :				int														=	rust_tokenizer.encode(A__      ,				add_special_tokens=A__							)
    self.assertListEqual(A__      ,				A__							)

    _snake_case   :				List[Any]														=	self.get_rust_tokenizer()
    _snake_case   :				Optional[Any]														=	tokenizer.encode(A__							)
    _snake_case   :				Optional[int]														=	rust_tokenizer.encode(A__							)
    self.assertListEqual(A__      ,				A__							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    _snake_case   :				List[str]														=	BasicTokenizer()

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







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				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 UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    _snake_case   :				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', '?']							)
    self.assertListEqual(tokenizer.tokenize('H\u00E9llo'							)      ,				['h\u00E9llo']							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    _snake_case   :				Dict														=	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 UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    _snake_case   :				Tuple														=	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 UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				Dict														=	BasicTokenizer(do_lower_case=A__							)

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







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


    '''simple docstring'''





    _snake_case   :				Tuple														=	BasicTokenizer(do_lower_case=A__      ,				strip_accents=A__							)

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







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    _snake_case   :				Optional[Any]														=	BasicTokenizer(do_lower_case=A__      ,				strip_accents=A__							)

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







  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    _snake_case   :				Union[str, Any]														=	BasicTokenizer(do_lower_case=A__      ,				never_split=['[UNK]']							)

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







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    _snake_case   :				List[str]														=	["""[UNK]""", """[CLS]""", """[SEP]""", """want""", """##want""", """##ed""", """wa""", """un""", """runn""", """##ing"""]

    _snake_case   :				Tuple														=	{}
    for i, token in enumerate(A__							):
      _snake_case   :				int														=	i
    _snake_case   :				Dict														=	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 UpperCamelCase_ (      self      :					Tuple							):


    '''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 UpperCamelCase_ (      self      :					Tuple							):


    '''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 UpperCamelCase_ (      self      :					Tuple							):


    '''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 UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    _snake_case   :				int														=	self.get_tokenizer()
    _snake_case   :				int														=	self.get_rust_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]']]							)

    self.assertListEqual(
        [rust_tokenizer.tokenize(A__							) for t in ['Test', '\xad', 'test']]      ,				[['[UNK]'], [], ['[UNK]']]							)







  @slow
  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    _snake_case   :				int														=	self.tokenizer_class.from_pretrained('google/mobilebert-uncased'							)

    _snake_case   :				List[Any]														=	tokenizer.encode('sequence builders'      ,				add_special_tokens=A__							)
    _snake_case   :				Optional[Any]														=	tokenizer.encode('multi-sequence build'      ,				add_special_tokens=A__							)

    _snake_case   :				List[Any]														=	tokenizer.build_inputs_with_special_tokens(A__							)
    _snake_case   :				Dict														=	tokenizer.build_inputs_with_special_tokens(A__      ,				A__							)

    assert encoded_sentence == [1_01] + text + [1_02]
    assert encoded_pair == [1_01] + text + [1_02] + text_a + [1_02]







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


    '''simple docstring'''





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

        _snake_case   :				int														=	f"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
        _snake_case   :				str														=	tokenizer_r.encode_plus(
            A__      ,				return_attention_mask=A__      ,				return_token_type_ids=A__      ,				return_offsets_mapping=A__      ,				add_special_tokens=A__      ,				)

        _snake_case   :				Optional[int]														=	tokenizer_r.do_lower_case if hasattr(A__      ,				'do_lower_case'							) else False
        _snake_case   :				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 UpperCamelCase_ (      self      :					List[Any]							):


    '''simple docstring'''





    _snake_case   :				Any														=	["""的""", """人""", """有"""]
    _snake_case   :				Union[str, Any]														=	"""""".join(A__							)
    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
      with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
        _snake_case   :				Tuple														=	True
        _snake_case   :				List[Any]														=	self.tokenizer_class.from_pretrained(A__      ,				**A__							)
        _snake_case   :				Optional[int]														=	self.rust_tokenizer_class.from_pretrained(A__      ,				**A__							)

        _snake_case   :				Dict														=	tokenizer_p.encode(A__      ,				add_special_tokens=A__							)
        _snake_case   :				str														=	tokenizer_r.encode(A__      ,				add_special_tokens=A__							)

        _snake_case   :				int														=	tokenizer_r.convert_ids_to_tokens(A__							)
        _snake_case   :				int														=	tokenizer_p.convert_ids_to_tokens(A__							)

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

        _snake_case   :				str														=	False
        _snake_case   :				List[Any]														=	self.rust_tokenizer_class.from_pretrained(A__      ,				**A__							)
        _snake_case   :				Optional[Any]														=	self.tokenizer_class.from_pretrained(A__      ,				**A__							)

        _snake_case   :				Union[str, Any]														=	tokenizer_r.encode(A__      ,				add_special_tokens=A__							)
        _snake_case   :				Union[str, Any]														=	tokenizer_p.encode(A__      ,				add_special_tokens=A__							)

        _snake_case   :				Optional[Any]														=	tokenizer_r.convert_ids_to_tokens(A__							)
        _snake_case   :				Any														=	tokenizer_p.convert_ids_to_tokens(A__							)

        # it is expected that only the first Chinese character is not preceded by "##".
        _snake_case   :				Optional[int]														=	[
            f"""##{token}""" if idx != 0 else token for idx, token in enumerate(A__							)
        ]
        self.assertListEqual(A__      ,				A__							)
        self.assertListEqual(A__      ,				A__							)








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     lowerCamelCase_	(      lowerCAmelCase:	str = N				)->		int:
  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() = }""")




