



from __future__ import annotations

from collections import Counter

def      A_ (		__a       :			List[Any]						):

				"""simple docstring"""
				a__			 =						[True] * n
				a__			 =						False
				a__			 =						False
				a__			 =						True

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

				a__			 =						[2]

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

				return primes

def      A_ (		__a       :			Optional[int]						):

				"""simple docstring"""
				a__			 =						str(__a						)
				a__			 =						[]
				a__			 =						["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

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

				return replacements

def      A_ (		__a       :			Optional[Any] = 8						):

				"""simple docstring"""
				a__			 =						set()

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

				for prime in primes:
								if prime in numbers_checked:
												continue

								a__			 =						digit_replacements(__a						)

								for family in replacements:
												numbers_checked.update(__a						)
												a__			 =						primes.intersection(__a						)

												if len(__a						) != family_length:
																continue

												return min(__a						)

				return -1


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






import unittest

from transformers import BlenderbotTokenizer, BlenderbotTokenizerFast
from transformers.utils import cached_property

class 	__snake_case (				unittest.TestCase):







							'''simple docstring'''






							@cached_property
							def _a (							self						):
											return BlenderbotTokenizer.from_pretrained("""facebook/blenderbot-3B"""						)


							@cached_property
							def _a (							self						):
											return BlenderbotTokenizerFast.from_pretrained("""facebook/blenderbot-3B"""						)


							def _a (							self						):
											a__			 =						self.tokenizer_ab
											a__			 =						""" I am a small frog."""
											a__			 =						tok([src_text]					,					padding=a_					,					truncation=a_						)["""input_ids"""]
											a__			 =						tok.batch_decode(a_					,					skip_special_tokens=a_					,					clean_up_tokenization_spaces=a_						)[0]
											assert src_text == decoded


							def _a (							self						):
											a__			 =						self.rust_tokenizer_ab
											a__			 =						""" I am a small frog."""
											a__			 =						tok([src_text]					,					padding=a_					,					truncation=a_						)["""input_ids"""]
											a__			 =						tok.batch_decode(a_					,					skip_special_tokens=a_					,					clean_up_tokenization_spaces=a_						)[0]
											assert src_text == decoded


							def _a (							self						):
											assert self.tokenizer_ab.add_prefix_space
											assert self.tokenizer_ab([""" Sam""", """Sam"""]						).input_ids == [[5_502, 2], [5_502, 2]]







							def _a (							self						):
											assert self.rust_tokenizer_ab.add_prefix_space
											assert self.rust_tokenizer_ab([""" Sam""", """Sam"""]						).input_ids == [[5_502, 2], [5_502, 2]]

