






from __future__ import annotations

from collections import Counter





def 						A_					(						lowercase_			)				->list[int]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		[True] * n
 SCREAMING_SNAKE_CASE				    =		False
 SCREAMING_SNAKE_CASE				    =		False
 SCREAMING_SNAKE_CASE				    =		True

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

 SCREAMING_SNAKE_CASE				    =		[2]

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

 return primes





def 						A_					(						lowercase_			)				->list[list[int]]:







 """simple docstring"""

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

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

 return replacements





def 						A_					(						lowercase_ = 8			)				->int:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		set()

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

 for prime in primes:
  if prime in numbers_checked:
   continue

  SCREAMING_SNAKE_CASE				    =		digit_replacements(lowercase_			)

  for family in replacements:
   numbers_checked.update(lowercase_			)
   SCREAMING_SNAKE_CASE				    =		primes.intersection(lowercase_			)

   if len(lowercase_			) != family_length:
    continue

   return min(lowercase_			)

 return -1


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






'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


A__ :		str					={'configuration_t5': ['T5_PRETRAINED_CONFIG_ARCHIVE_MAP', 'T5Config', 'T5OnnxConfig']}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     A__ :		Optional[int]					=['T5Tokenizer']

try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     A__ :		Union[str, Any]					=['T5TokenizerFast']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     A__ :		Union[str, Any]					=[
         'T5_PRETRAINED_MODEL_ARCHIVE_LIST',
         'T5EncoderModel',
         'T5ForConditionalGeneration',
         'T5Model',
         'T5PreTrainedModel',
         'load_tf_weights_in_t5',
         'T5ForQuestionAnswering',
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     A__ :		List[str]					=[
         'TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST',
         'TFT5EncoderModel',
         'TFT5ForConditionalGeneration',
         'TFT5Model',
         'TFT5PreTrainedModel',
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     A__ :		Union[str, Any]					=[
         'FlaxT5EncoderModel',
         'FlaxT5ForConditionalGeneration',
         'FlaxT5Model',
         'FlaxT5PreTrainedModel',
     ]


if TYPE_CHECKING:
     from .configuration_ta import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TaConfig, TaOnnxConfig

     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_ta import TaTokenizer

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_ta_fast import TaTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_ta import (
              T5_PRETRAINED_MODEL_ARCHIVE_LIST,
              TaEncoderModel,
              TaForConditionalGeneration,
              TaForQuestionAnswering,
              TaModel,
              TaPreTrainedModel,
              load_tf_weights_in_ta,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_ta import (
              TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
              TFTaEncoderModel,
              TFTaForConditionalGeneration,
              TFTaModel,
              TFTaPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_ta import (
              FlaxTaEncoderModel,
              FlaxTaForConditionalGeneration,
              FlaxTaModel,
              FlaxTaPreTrainedModel,
          )


else:
     import sys

     A__ :		Dict					=_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



