



from __future__ import annotations

from collections import Counter



def   __lowerCamelCase  (   lowerCAmelCase_						)    ->   list[int]:
		_a  :   Optional[Any]				 =							[True] * n
		_a  :   str				 =							False
		_a  :   Any				 =							False
		_a  :   List[Any]				 =							True

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

		_a  :   int				 =							[2]

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

		return primes



def   __lowerCamelCase  (   lowerCAmelCase_						)    ->   list[list[int]]:
		_a  :   Any				 =							str(lowerCAmelCase_						)
		_a  :   List[str]				 =							[]
		_a  :   Optional[Any]				 =							['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

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

		return replacements



def   __lowerCamelCase  (   lowerCAmelCase_ = 8						)    ->   int:
		_a  :   int				 =							set()

		# Filter primes with less than 3 replaceable digits
		_a  :   Any				 =							{
		    x for x in set(prime_sieve(1000000						)						) if len(str(lowerCAmelCase_						)						) - len(set(str(lowerCAmelCase_						)						)						) >= 3
		}

		for prime in primes:
				if prime in numbers_checked:
						continue

				_a  :   Any				 =							digit_replacements(lowerCAmelCase_						)

				for family in replacements:
						numbers_checked.update(lowerCAmelCase_						)
						_a  :   Dict				 =							primes.intersection(lowerCAmelCase_						)

						if len(lowerCAmelCase_						) != family_length:
								continue

						return min(lowerCAmelCase_						)

		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,
)


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

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

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase		    =     ['''T5TokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase		    =     [
							    '''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:
							__lowerCAmelCase		    =     [
							    '''TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFT5EncoderModel''',
							    '''TFT5ForConditionalGeneration''',
							    '''TFT5Model''',
							    '''TFT5PreTrainedModel''',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase		    =     [
							    '''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

							__lowerCAmelCase		    =     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




