
import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
  from tokenizers import Tokenizer
  from tokenizers.models import WordPiece

class 		__magic_name__				( unittest.TestCase					):


  """simple docstring"""





  def     _UpperCAmelCase  (					self	,		a__		):
    _lowerCamelCase      =						list(tokenizer_class.max_model_input_sizes.keys()		)
    for model_name in sa_models[:1]:
      _lowerCamelCase      =						tokenizer_class.from_pretrained(A__		)
      self.assertIsNotNone(A__		)
      self.assertIsInstance(A__	,		A__		)
      self.assertIsInstance(A__	,		A__		)

      for special_tok in tokenizer.all_special_tokens:
        self.assertIsInstance(A__	,		A__		)
        _lowerCamelCase      =						tokenizer.convert_tokens_to_ids(A__		)
        self.assertIsInstance(A__	,		A__		)


  def     _UpperCAmelCase  (					self	,		a__	,		a__ = None		):
    _lowerCamelCase      =						pickle.dumps(A__		)
    self.assertIsNotNone(A__		)

    _lowerCamelCase      =						pickle.loads(A__		)

    # Ensure is_fast is correctly restored
    self.assertEqual(be_restored.is_fast	,		be_original.is_fast		)

    # Ensure encodings are potentially correctly restored
    if be_original.is_fast:
      self.assertIsNotNone(be_restored.encodings		)
    else:
      self.assertIsNone(be_restored.encodings		)

    # Ensure the keys are the same
    for original_v, restored_v in zip(be_original.values()	,		be_restored.values()		):
      if equal_op:
        self.assertTrue(equal_op(A__	,		A__		)		)
      else:
        self.assertEqual(A__	,		A__		)


  @slow
  def     _UpperCAmelCase  (					self		):
    self.check_tokenizer_from_pretrained(A__		)


  def     _UpperCAmelCase  (					self		):
    self.assertEqual(TensorType('''tf'''		)	,		TensorType.TENSORFLOW		)
    self.assertEqual(TensorType('''pt'''		)	,		TensorType.PYTORCH		)
    self.assertEqual(TensorType('''np'''		)	,		TensorType.NUMPY		)


  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    import numpy as np

    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)
    _lowerCamelCase      =						BertTokenizerFast.from_pretrained('''bert-base-cased'''		)

    # Python no tensor
    with self.subTest('''BatchEncoding (Python, return_tensors=None)'''		):
      self.assert_dump_and_restore(tokenizer_p('''Small example to encode'''		)		)

    with self.subTest('''BatchEncoding (Python, return_tensors=NUMPY)'''		):
      self.assert_dump_and_restore(
          tokenizer_p('''Small example to encode'''	,		return_tensors=TensorType.NUMPY		)	,		np.array_equal		)

    with self.subTest('''BatchEncoding (Rust, return_tensors=None)'''		):
      self.assert_dump_and_restore(tokenizer_r('''Small example to encode'''		)		)

    with self.subTest('''BatchEncoding (Rust, return_tensors=NUMPY)'''		):
      self.assert_dump_and_restore(
          tokenizer_r('''Small example to encode'''	,		return_tensors=TensorType.NUMPY		)	,		np.array_equal		)


  @require_tf
  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    import tensorflow as tf

    def tf_array_equals(a__	,		a__		):
      return tf.reduce_all(tf.equal(A__	,		A__		)		)

    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)
    _lowerCamelCase      =						BertTokenizerFast.from_pretrained('''bert-base-cased'''		)

    with self.subTest('''BatchEncoding (Python, return_tensors=TENSORFLOW)'''		):
      self.assert_dump_and_restore(
          tokenizer_p('''Small example to encode'''	,		return_tensors=TensorType.TENSORFLOW		)	,		A__		)

    with self.subTest('''BatchEncoding (Rust, return_tensors=TENSORFLOW)'''		):
      self.assert_dump_and_restore(
          tokenizer_r('''Small example to encode'''	,		return_tensors=TensorType.TENSORFLOW		)	,		A__		)


  @require_torch
  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    import torch

    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)
    _lowerCamelCase      =						BertTokenizerFast.from_pretrained('''bert-base-cased'''		)

    with self.subTest('''BatchEncoding (Python, return_tensors=PYTORCH)'''		):
      self.assert_dump_and_restore(
          tokenizer_p('''Small example to encode'''	,		return_tensors=TensorType.PYTORCH		)	,		torch.equal		)

    with self.subTest('''BatchEncoding (Rust, return_tensors=PYTORCH)'''		):
      self.assert_dump_and_restore(
          tokenizer_r('''Small example to encode'''	,		return_tensors=TensorType.PYTORCH		)	,		torch.equal		)


  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)
    _lowerCamelCase      =						BertTokenizerFast.from_pretrained('''bert-base-cased'''		)

    with self.subTest('''Python Tokenizer'''		):
      self.assertFalse(tokenizer_p('''Small example to_encode'''		).is_fast		)

    with self.subTest('''Rust Tokenizer'''		):
      self.assertTrue(tokenizer_r('''Small example to_encode'''		).is_fast		)


  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						BertTokenizerFast.from_pretrained('''bert-base-cased'''		)
    _lowerCamelCase      =						tokenizer_r(['''Test''', '''\xad''', '''test''']	,		is_split_into_words=A__		)

    self.assertEqual(encoded.word_to_tokens(0		)	,		TokenSpan(start=1	,		end=2		)		)
    self.assertEqual(encoded.word_to_tokens(1		)	,		A__		)
    self.assertEqual(encoded.word_to_tokens(2		)	,		TokenSpan(start=2	,		end=3		)		)


  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''np'''		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(2, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(2,)		)
    # test converting the converted
    with CaptureStderr() as cs:
      _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''np'''		)
    self.assertFalse(len(cs.err		)	,		msg=f'''should have no warning, but got {cs.err}'''		)

    _lowerCamelCase      =						BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''np'''	,		prepend_batch_axis=A__		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(1, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(1,)		)


  @require_torch
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''pt'''		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(2, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(2,)		)
    # test converting the converted
    with CaptureStderr() as cs:
      _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''pt'''		)
    self.assertFalse(len(cs.err		)	,		msg=f'''should have no warning, but got {cs.err}'''		)

    _lowerCamelCase      =						BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''pt'''	,		prepend_batch_axis=A__		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(1, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(1,)		)


  @require_tf
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''tf'''		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(2, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(2,)		)
    # test converting the converted
    with CaptureStderr() as cs:
      _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''tf'''		)
    self.assertFalse(len(cs.err		)	,		msg=f'''should have no warning, but got {cs.err}'''		)

    _lowerCamelCase      =						BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''tf'''	,		prepend_batch_axis=A__		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(1, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(1,)		)


  @require_flax
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''jax'''		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(2, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(2,)		)
    # test converting the converted
    with CaptureStderr() as cs:
      _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''jax'''		)
    self.assertFalse(len(cs.err		)	,		msg=f'''should have no warning, but got {cs.err}'''		)

    _lowerCamelCase      =						BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}		)
    _lowerCamelCase      =						batch.convert_to_tensors(tensor_type='''jax'''	,		prepend_batch_axis=A__		)
    self.assertEqual(tensor_batch['''inputs'''].shape	,		(1, 3)		)
    self.assertEqual(tensor_batch['''labels'''].shape	,		(1,)		)


  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						[{'''input_ids''': np.array([0, 1, 2]		)}, {'''input_ids''': np.array([0, 1, 2, 3]		)}]
    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)

    _lowerCamelCase      =						tokenizer.pad(A__	,		padding=A__		)
    self.assertTrue(isinstance(batch['''input_ids''']	,		np.ndarray		)		)
    self.assertEqual(batch['''input_ids'''].tolist()	,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]		)
    _lowerCamelCase      =						tokenizer.pad(A__	,		padding=A__	,		return_tensors='''np'''		)
    self.assertTrue(isinstance(batch['''input_ids''']	,		np.ndarray		)		)
    self.assertEqual(batch['''input_ids'''].tolist()	,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]		)


  @require_torch
  def     _UpperCAmelCase  (					self		):
    import torch

    _lowerCamelCase      =						[{'''input_ids''': torch.tensor([0, 1, 2]		)}, {'''input_ids''': torch.tensor([0, 1, 2, 3]		)}]
    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)

    _lowerCamelCase      =						tokenizer.pad(A__	,		padding=A__		)
    self.assertTrue(isinstance(batch['''input_ids''']	,		torch.Tensor		)		)
    self.assertEqual(batch['''input_ids'''].tolist()	,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]		)
    _lowerCamelCase      =						tokenizer.pad(A__	,		padding=A__	,		return_tensors='''pt'''		)
    self.assertTrue(isinstance(batch['''input_ids''']	,		torch.Tensor		)		)
    self.assertEqual(batch['''input_ids'''].tolist()	,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]		)


  @require_tf
  def     _UpperCAmelCase  (					self		):
    import tensorflow as tf

    _lowerCamelCase      =						[{'''input_ids''': tf.constant([0, 1, 2]		)}, {'''input_ids''': tf.constant([0, 1, 2, 3]		)}]
    _lowerCamelCase      =						BertTokenizer.from_pretrained('''bert-base-cased'''		)

    _lowerCamelCase      =						tokenizer.pad(A__	,		padding=A__		)
    self.assertTrue(isinstance(batch['''input_ids''']	,		tf.Tensor		)		)
    self.assertEqual(batch['''input_ids'''].numpy().tolist()	,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]		)
    _lowerCamelCase      =						tokenizer.pad(A__	,		padding=A__	,		return_tensors='''tf'''		)
    self.assertTrue(isinstance(batch['''input_ids''']	,		tf.Tensor		)		)
    self.assertEqual(batch['''input_ids'''].numpy().tolist()	,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]		)


  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						Tokenizer(WordPiece(unk_token='''[UNK]'''		)		)
    PreTrainedTokenizerFast(tokenizer_object=A__		)


  @require_tokenizers
  def     _UpperCAmelCase  (					self		):
    _lowerCamelCase      =						Tokenizer(WordPiece(unk_token='''[UNK]'''		)		)
    with tempfile.TemporaryDirectory() as tmpdirname:
      bert_tokenizer.save(os.path.join(A__	,		'''tokenizer.json'''		)		)
      PreTrainedTokenizerFast(tokenizer_file=os.path.join(A__	,		'''tokenizer.json'''		)		)







from __future__ import annotations

from collections import Counter



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  _snake_case		=				[True] * n
  _snake_case		=				False
  _snake_case		=				False
  _snake_case		=				True

  for i in range(3					,			int(n**0.5 + 1	)					,			2	):
    _snake_case		=				i * 2
    while index < n:
      _snake_case		=				False
      _snake_case		=				index + i

  _snake_case		=				[2]

  for i in range(3					,			_UpperCamelCase					,			2	):
    if is_prime[i]:
      primes.append(_UpperCamelCase	)

  return primes



def  snake_case_(_UpperCamelCase	)				->      list[list[int]]:



  """simple docstring"""






  _snake_case		=				str(_UpperCamelCase	)
  _snake_case		=				[]
  _snake_case		=				['''0''', '''1''', '''2''', '''3''', '''4''', '''5''', '''6''', '''7''', '''8''', '''9''']

  for duplicate in Counter(_UpperCamelCase	) - Counter(set(_UpperCamelCase	)	):
    _snake_case		=				[int(number_str.replace(_UpperCamelCase					,			_UpperCamelCase	)	) for digit in digits]
    replacements.append(_UpperCamelCase	)

  return replacements



def  snake_case_(_UpperCamelCase = 8	)				->      int:



  """simple docstring"""






  _snake_case		=				set()

  # Filter primes with less than 3 replaceable digits
  _snake_case		=				{
      x for x in set(prime_sieve(1_000_000	)	) if len(str(_UpperCamelCase	)	) - len(set(str(_UpperCamelCase	)	)	) >= 3
  }

  for prime in primes:
    if prime in numbers_checked:
      continue

    _snake_case		=				digit_replacements(_UpperCamelCase	)

    for family in replacements:
      numbers_checked.update(_UpperCamelCase	)
      _snake_case		=				primes.intersection(_UpperCamelCase	)

      if len(_UpperCamelCase	) != family_length:
        continue

      return min(_UpperCamelCase	)

  return -1


if __name__ == "__main__":
 print(solution())

