code: 
  
  import os
  import unittest
  
  from transformers import ElectraTokenizerFast
  from transformers.models.electra.tokenization_electra import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      ElectraTokenizer,
      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 __UpperCamelCase    (							_a				,unittest.TestCase		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      ElectraTokenizer
  					__magic_name__     			=      ElectraTokenizerFast
  					__magic_name__     			=      True
  					__magic_name__     			=      True
  					__magic_name__     			=      filter_non_english
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						super().setUp()
  
  						UpperCAmelCase__:  Union[str, Any]		       =   [
  						    "[UNK]",
  						    "[CLS]",
  						    "[SEP]",
  						    "[PAD]",
  						    "[MASK]",
  						    "want",
  						    "##want",
  						    "##ed",
  						    "wa",
  						    "un",
  						    "runn",
  						    "##ing",
  						    ",",
  						    "low",
  						    "lowest",
  						]
  						UpperCAmelCase__:  Optional[Any]		       =   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       _UpperCAmelCase						(							self							,			lowerCamelCase__	):
  						UpperCAmelCase__:  Union[str, Any]		       =   "UNwant\u00E9d,running"
  						UpperCAmelCase__:  int		       =   "unwanted, running"
  						return input_text, output_text
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Any		       =   self.tokenizer_class(self.vocab_file	)
  
  						UpperCAmelCase__:  Optional[int]		       =   tokenizer.tokenize("UNwant\u00E9d,running"	)
  						self.assertListEqual(lowerCamelCase__							,			["un", "##want", "##ed", ",", "runn", "##ing"]	)
  						self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase__	)							,			[9, 6, 7, 1_2, 1_0, 1_1]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						if not self.test_rust_tokenizer:
  							return
  
  						UpperCAmelCase__:  int		       =   self.get_tokenizer()
  						UpperCAmelCase__:  List[str]		       =   self.get_rust_tokenizer()
  
  						UpperCAmelCase__:  Optional[int]		       =   "UNwant\u00E9d,running"
  
  						UpperCAmelCase__:  Any		       =   tokenizer.tokenize(lowerCamelCase__	)
  						UpperCAmelCase__:  Dict		       =   rust_tokenizer.tokenize(lowerCamelCase__	)
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  						UpperCAmelCase__:  Tuple		       =   tokenizer.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  						UpperCAmelCase__:  List[str]		       =   rust_tokenizer.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[Any]		       =   self.get_rust_tokenizer()
  						UpperCAmelCase__:  List[Any]		       =   tokenizer.encode(lowerCamelCase__	)
  						UpperCAmelCase__:  Dict		       =   rust_tokenizer.encode(lowerCamelCase__	)
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  						# With lower casing
  						UpperCAmelCase__:  int		       =   self.get_tokenizer(do_lower_case=lowerCamelCase__	)
  						UpperCAmelCase__:  Optional[Any]		       =   self.get_rust_tokenizer(do_lower_case=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Any		       =   "UNwant\u00E9d,running"
  
  						UpperCAmelCase__:  Optional[int]		       =   tokenizer.tokenize(lowerCamelCase__	)
  						UpperCAmelCase__:  int		       =   rust_tokenizer.tokenize(lowerCamelCase__	)
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[Any]		       =   tokenizer.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  						UpperCAmelCase__:  Any		       =   rust_tokenizer.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[Any]		       =   self.get_rust_tokenizer()
  						UpperCAmelCase__:  Tuple		       =   tokenizer.encode(lowerCamelCase__	)
  						UpperCAmelCase__:  List[Any]		       =   rust_tokenizer.encode(lowerCamelCase__	)
  						self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Tuple		       =   BasicTokenizer()
  
  						self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"	)							,			["ah", "\u535A", "\u63A8", "zz"]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  int		       =   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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Dict		       =   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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Tuple		       =   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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  int		       =   BasicTokenizer(do_lower_case=lowerCamelCase__	)
  
  						self.assertListEqual(
  						    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "	)							,			["HeLLo", "!", "how", "Are", "yoU", "?"]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Dict		       =   BasicTokenizer(do_lower_case=lowerCamelCase__							,			strip_accents=lowerCamelCase__	)
  
  						self.assertListEqual(
  						    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "	)							,			["HäLLo", "!", "how", "Are", "yoU", "?"]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Dict		       =   BasicTokenizer(do_lower_case=lowerCamelCase__							,			never_split=["[UNK]"]	)
  
  						self.assertListEqual(
  						    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"	)							,			["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[Any]		       =   ["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]
  
  						UpperCAmelCase__:  int		       =   {}
  						for i, token in enumerate(lowerCamelCase__	):
  							UpperCAmelCase__:  Optional[int]		       =   i
  						UpperCAmelCase__:  Any		       =   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       _UpperCAmelCase						(							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       _UpperCAmelCase						(							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       _UpperCAmelCase						(							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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   self.get_tokenizer()
  						UpperCAmelCase__:  List[Any]		       =   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       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  List[str]		       =   self.tokenizer_class.from_pretrained("google/electra-base-discriminator"	)
  
  						UpperCAmelCase__:  Optional[Any]		       =   tokenizer.encode("sequence builders"							,			add_special_tokens=lowerCamelCase__	)
  						UpperCAmelCase__:  Optional[Any]		       =   tokenizer.encode("multi-sequence build"							,			add_special_tokens=lowerCamelCase__	)
  
  						UpperCAmelCase__:  Optional[int]		       =   tokenizer.build_inputs_with_special_tokens(lowerCamelCase__	)
  						UpperCAmelCase__:  Optional[Any]		       =   tokenizer.build_inputs_with_special_tokens(lowerCamelCase__							,			lowerCamelCase__	)
  
  						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       _UpperCAmelCase						(							self	):
  						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  							with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"	):
  								UpperCAmelCase__:  Optional[Any]		       =   self.rust_tokenizer_class.from_pretrained(lowerCamelCase__							,			**lowerCamelCase__	)
  
  								UpperCAmelCase__:  List[Any]		       =   F"A, naïve {tokenizer_r.mask_token} AllenNLP sentence."
  								UpperCAmelCase__:  List[str]		       =   tokenizer_r.encode_plus(
  								    lowerCamelCase__							,			return_attention_mask=lowerCamelCase__							,			return_token_type_ids=lowerCamelCase__							,			return_offsets_mapping=lowerCamelCase__							,			add_special_tokens=lowerCamelCase__							,			)
  
  								UpperCAmelCase__:  Optional[int]		       =   tokenizer_r.do_lower_case if hasattr(lowerCamelCase__							,			"do_lower_case"	) else False
  								UpperCAmelCase__:  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"]	)
  
  
  
  
  
  					def       _UpperCAmelCase						(							self	):
  						UpperCAmelCase__:  Union[str, Any]		       =   ["的", "人", "有"]
  						UpperCAmelCase__:  Tuple		       =   "".join(lowerCamelCase__	)
  						for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  							with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"	):
  								UpperCAmelCase__:  Dict		       =   True
  								UpperCAmelCase__:  List[str]		       =   self.tokenizer_class.from_pretrained(lowerCamelCase__							,			**lowerCamelCase__	)
  								UpperCAmelCase__:  Optional[int]		       =   self.rust_tokenizer_class.from_pretrained(lowerCamelCase__							,			**lowerCamelCase__	)
  
  								UpperCAmelCase__:  int		       =   tokenizer_p.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  								UpperCAmelCase__:  str		       =   tokenizer_r.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  
  								UpperCAmelCase__:  Optional[Any]		       =   tokenizer_r.convert_ids_to_tokens(lowerCamelCase__	)
  								UpperCAmelCase__:  str		       =   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__:  Any		       =   False
  								UpperCAmelCase__:  Union[str, Any]		       =   self.rust_tokenizer_class.from_pretrained(lowerCamelCase__							,			**lowerCamelCase__	)
  								UpperCAmelCase__:  Dict		       =   self.tokenizer_class.from_pretrained(lowerCamelCase__							,			**lowerCamelCase__	)
  
  								UpperCAmelCase__:  Tuple		       =   tokenizer_r.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  								UpperCAmelCase__:  List[str]		       =   tokenizer_p.encode(lowerCamelCase__							,			add_special_tokens=lowerCamelCase__	)
  
  								UpperCAmelCase__:  Any		       =   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__:  Union[str, Any]		       =   [
  								    F"##{token}" if idx != 0 else token for idx, token in enumerate(lowerCamelCase__	)
  								]
  								self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
  								self.assertListEqual(lowerCamelCase__							,			lowerCamelCase__	)
style_context: 
  
  from __future__ import annotations
  
  from collections import Counter
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Optional[Any]		       =   [True] * n
  	UpperCAmelCase__:  Any		       =   False
  	UpperCAmelCase__:  Tuple		       =   False
  	UpperCAmelCase__:  Optional[Any]		       =   True
  
  	for i in range(3  ,int(n**0.5 + 1			)  ,2			):
  		UpperCAmelCase__:  Any		       =   i * 2
  		while index < n:
  			UpperCAmelCase__:  Optional[int]		       =   False
  			UpperCAmelCase__:  Tuple		       =   index + i
  
  	UpperCAmelCase__:  int		       =   [2]
  
  	for i in range(3  ,SCREAMING_SNAKE_CASE  ,2			):
  		if is_prime[i]:
  			primes.append(SCREAMING_SNAKE_CASE			)
  
  	return primes
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  List[Any]		       =   str(SCREAMING_SNAKE_CASE			)
  	UpperCAmelCase__:  Tuple		       =   []
  	UpperCAmelCase__:  Optional[int]		       =   ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
  
  	for duplicate in Counter(SCREAMING_SNAKE_CASE			) - Counter(set(SCREAMING_SNAKE_CASE			)			):
  		UpperCAmelCase__:  Optional[Any]		       =   [int(number_str.replace(SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			)			) for digit in digits]
  		replacements.append(SCREAMING_SNAKE_CASE			)
  
  	return replacements
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE = 8			):
  	UpperCAmelCase__:  Union[str, Any]		       =   set()
  
  	# Filter primes with less than 3 replaceable digits
  	UpperCAmelCase__:  Optional[Any]		       =   {
  	    x for x in set(prime_sieve(1_0_0_0_0_0_0			)			) if len(str(SCREAMING_SNAKE_CASE			)			) - len(set(str(SCREAMING_SNAKE_CASE			)			)			) >= 3
  	}
  
  	for prime in primes:
  		if prime in numbers_checked:
  			continue
  
  		UpperCAmelCase__:  Optional[int]		       =   digit_replacements(SCREAMING_SNAKE_CASE			)
  
  		for family in replacements:
  			numbers_checked.update(SCREAMING_SNAKE_CASE			)
  			UpperCAmelCase__:  Dict		       =   primes.intersection(SCREAMING_SNAKE_CASE			)
  
  			if len(SCREAMING_SNAKE_CASE			) != family_length:
  				continue
  
  			return min(SCREAMING_SNAKE_CASE			)
  
  	return -1
  
  
  if __name__ == "__main__":
  					print(solution())