

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        _a		(_A						,  unittest.TestCase							):


					'''simple docstring'''






					UpperCAmelCase__:  List[Any]    				=			MobileBertTokenizer
					UpperCAmelCase__:  int    				=			MobileBertTokenizerFast
					UpperCAmelCase__:  List[str]    				=			True
					UpperCAmelCase__:  Dict    				=			True
					UpperCAmelCase__:  Any    				=			filter_non_english
					UpperCAmelCase__:  Tuple    				=			'''google/mobilebert-uncased'''






					def     __A     (					self     ):
						super().setUp()

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

						A__				:       int	  =						[
						    (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     __A     (					self       ,			A__     ):
						A__				:       Dict	  =						"UNwant\u00E9d,running"
						A__				:       Any	  =						"unwanted, running"
						return input_text, output_text






					def     __A     (					self     ):
						A__				:       List[str]	  =						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, 12, 10, 11]     )






					def     __A     (					self     ):
						if not self.test_rust_tokenizer:
							return

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

						A__				:       Optional[int]	  =						"UNwant\u00E9d,running"

						A__				:       List[Any]	  =						tokenizer.tokenize(a_     )
						A__				:       Union[str, Any]	  =						rust_tokenizer.tokenize(a_     )
						self.assertListEqual(a_       ,			a_     )

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

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

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

						A__				:       Dict	  =						"UNwant\u00E9d,running"

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

						A__				:       Any	  =						tokenizer.encode(a_       ,			add_special_tokens=a_     )
						A__				:       Union[str, Any]	  =						rust_tokenizer.encode(a_       ,			add_special_tokens=a_     )
						self.assertListEqual(a_       ,			a_     )

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






					def     __A     (					self     ):
						A__				:       List[str]	  =						BasicTokenizer()

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






					def     __A     (					self     ):
						A__				:       Tuple	  =						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     __A     (					self     ):
						A__				:       List[str]	  =						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     __A     (					self     ):
						A__				:       Any	  =						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     __A     (					self     ):
						A__				:       Optional[int]	  =						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     __A     (					self     ):
						A__				:       Optional[Any]	  =						BasicTokenizer(do_lower_case=a_     )

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






					def     __A     (					self     ):
						A__				:       Any	  =						BasicTokenizer(do_lower_case=a_       ,			strip_accents=a_     )

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






					def     __A     (					self     ):
						A__				:       str	  =						BasicTokenizer(do_lower_case=a_       ,			strip_accents=a_     )

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






					def     __A     (					self     ):
						A__				:       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     __A     (					self     ):
						A__				:       Optional[int]	  =						["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

						A__				:       Dict	  =						{}
						for i, token in enumerate(a_     ):
							A__				:       int	  =						i
						A__				:       Optional[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     __A     (					self     ):
						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     __A     (					self     ):
						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     __A     (					self     ):
						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     __A     (					self     ):
						A__				:       Union[str, Any]	  =						self.get_tokenizer()
						A__				:       Dict	  =						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     __A     (					self     ):
						A__				:       Any	  =						self.tokenizer_class.from_pretrained("""google/mobilebert-uncased"""     )

						A__				:       Tuple	  =						tokenizer.encode("""sequence builders"""       ,			add_special_tokens=a_     )
						A__				:       Dict	  =						tokenizer.encode("""multi-sequence build"""       ,			add_special_tokens=a_     )

						A__				:       Union[str, Any]	  =						tokenizer.build_inputs_with_special_tokens(a_     )
						A__				:       Union[str, Any]	  =						tokenizer.build_inputs_with_special_tokens(a_       ,			a_     )

						assert encoded_sentence == [101] + text + [102]
						assert encoded_pair == [101] + text + [102] + text_a + [102]






					def     __A     (					self     ):
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
							with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""     ):
								A__				:       str	  =						self.rust_tokenizer_class.from_pretrained(a_       ,			**a_     )

								A__				:       List[str]	  =						F"""A, naïve {tokenizer_r.mask_token} AllenNLP sentence."""
								A__				:       Optional[int]	  =						tokenizer_r.encode_plus(
								    a_       ,			return_attention_mask=a_       ,			return_token_type_ids=a_       ,			return_offsets_mapping=a_       ,			add_special_tokens=a_       ,			)

								A__				:       List[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, 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     __A     (					self     ):
						A__				:       Union[str, Any]	  =						["的", "人", "有"]
						A__				:       Dict	  =						"".join(a_     )
						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
							with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""     ):
								A__				:       int	  =						True
								A__				:       Any	  =						self.tokenizer_class.from_pretrained(a_       ,			**a_     )
								A__				:       Tuple	  =						self.rust_tokenizer_class.from_pretrained(a_       ,			**a_     )

								A__				:       List[Any]	  =						tokenizer_p.encode(a_       ,			add_special_tokens=a_     )
								A__				:       int	  =						tokenizer_r.encode(a_       ,			add_special_tokens=a_     )

								A__				:       List[str]	  =						tokenizer_r.convert_ids_to_tokens(a_     )
								A__				:       Union[str, Any]	  =						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_     )

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

								A__				:       Dict	  =						tokenizer_r.encode(a_       ,			add_special_tokens=a_     )
								A__				:       int	  =						tokenizer_p.encode(a_       ,			add_special_tokens=a_     )

								A__				:       Tuple	  =						tokenizer_r.convert_ids_to_tokens(a_     )
								A__				:       int	  =						tokenizer_p.convert_ids_to_tokens(a_     )

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










'''simple docstring'''






lowerCAmelCase									=   [sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(10_00_00)]






def   __A    (				a_    :	int						):
		lowerCAmelCase  :     Optional[int]       						= 0
		while number:
				# Increased Speed Slightly by checking every 5 digits together.
				sum_of_digits_squared += DIGITS_SQUARED[number % 1_0_0_0_0_0]
				number //= 1_0_0_0_0_0

		return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
lowerCAmelCase									=   [None] * 10_00_00_00
lowerCAmelCase									=   True
lowerCAmelCase									=   False






def   __A    (				a_    :	int						):

		if CHAINS[number - 1] is not None:
				return CHAINS[number - 1]  # type: ignore

		lowerCAmelCase  :     Dict       						= chain(next_number(a_						)						)
		lowerCAmelCase  :     Union[str, Any]       						= number_chain

		while number < 1_0_0_0_0_0_0_0:
				lowerCAmelCase  :     Any       						= number_chain
				number *= 1_0

		return number_chain






def   __A    (				a_    :	int = 1_0_0_0_0_0_0_0						):
		for i in range(1   ,a_						):
				if CHAINS[i] is None:
						chain(i + 1						)

		return CHAINS[:number].count(a_						)


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					print(F'''{solution() = }''')



