
from __future__ import annotations

from collections import Counter


def       a			(   a  )    ->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		,	a		,	2  ):
						if is_prime[i]:
									primes.append(a  )

			return primes


def       a			(   a  )    ->list[list[int]]:




			'''simple docstring'''


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

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

			return replacements


def       a			(   a = 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(100_0000  )  ) if len(str(a  )  ) - len(set(str(a  )  )  ) >= 3
			}

			for prime in primes:
						if prime in numbers_checked:
									continue

						SCREAMING_SNAKE_CASE    	=   digit_replacements(a  )

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

									if len(a  ) != family_length:
												continue

									return min(a  )

			return -1


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



from __future__ import annotations

__lowerCAmelCase				      =					[2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]





class 						lowerCamelCase			:







	def __init__(    self			:List[str]      ,    lowercase			:int )		->			None:







				"""simple docstring"""






				SCREAMING_SNAKE_CASE    	=   -1
				SCREAMING_SNAKE_CASE    	=   -1
				SCREAMING_SNAKE_CASE    	=   [-1] * length
				SCREAMING_SNAKE_CASE    	=   None
				SCREAMING_SNAKE_CASE    	=   None







	def __repr__(    self			:List[Any] )		->			str:







				"""simple docstring"""






				return f"""Node(min_value={self.minn} max_value={self.maxx})"""



def       a			(   a  )    ->Node | None:




			'''simple docstring'''


			SCREAMING_SNAKE_CASE    	=   Node(len(a  )  )
			SCREAMING_SNAKE_CASE	,       SCREAMING_SNAKE_CASE    	=   min(a  ), max(a  )
			# Leaf node case where the node contains only one unique value
			if root.minn == root.maxx:
						return root
			SCREAMING_SNAKE_CASE    	=   (root.minn + root.maxx) // 2

			SCREAMING_SNAKE_CASE    	=   []
			SCREAMING_SNAKE_CASE    	=   []

			for index, num in enumerate(a  ):
						if num <= pivot:
									left_arr.append(a  )
						else:
									right_arr.append(a  )
						SCREAMING_SNAKE_CASE    	=   len(a  )
			SCREAMING_SNAKE_CASE    	=   build_tree(a  )
			SCREAMING_SNAKE_CASE    	=   build_tree(a  )
			return root


def       a			(   a		,	a		,	a  )    ->int:




			'''simple docstring'''


			if index < 0 or node is None:
						return 0
			# Leaf node cases
			if node.minn == node.maxx:
						return index + 1 if node.minn == num else 0
			SCREAMING_SNAKE_CASE    	=   (node.minn + node.maxx) // 2
			if num <= pivot:
						# go the left subtree and map index to the left subtree
						return rank_till_index(node.left		,	a		,	node.map_left[index] - 1  )
			else:
						# go to the right subtree and map index to the right subtree
						return rank_till_index(node.right		,	a		,	index - node.map_left[index]  )


def       a			(   a		,	a		,	a		,	a  )    ->int:




			'''simple docstring'''


			if start > end:
						return 0
			SCREAMING_SNAKE_CASE    	=   rank_till_index(a		,	a		,	a  )
			SCREAMING_SNAKE_CASE    	=   rank_till_index(a		,	a		,	start - 1  )
			return rank_till_end - rank_before_start


def       a			(   a		,	a		,	a		,	a  )    ->int:




			'''simple docstring'''


			if index > (end - start) or start > end or node is None:
						return -1
			# Leaf node case
			if node.minn == node.maxx:
						return node.minn
			# Number of elements in the left subtree in interval [start, end]
			SCREAMING_SNAKE_CASE    	=   node.map_left[end] - (
			    node.map_left[start - 1] if start else 0
			)
			if num_elements_in_left_tree > index:
						return quantile(
						    node.left		,	a		,	(node.map_left[start - 1] if start else 0)		,	node.map_left[end] - 1		,	)
			else:
						return quantile(
						    node.right		,	index - num_elements_in_left_tree		,	start - (node.map_left[start - 1] if start else 0)		,	end - node.map_left[end]		,	)


def       a			(   a		,	a		,	a		,	a		,	a  )    ->int:




			'''simple docstring'''


			if (
			    start > end
			    or node is None
			    or start_num > end_num
			    or node.minn > end_num
			    or node.maxx < start_num
			):
						return 0
			if start_num <= node.minn and node.maxx <= end_num:
						return end - start + 1
			SCREAMING_SNAKE_CASE    	=   range_counting(
			    node.left		,	(node.map_left[start - 1] if start else 0)		,	node.map_left[end] - 1		,	a		,	a		,	)
			SCREAMING_SNAKE_CASE    	=   range_counting(
			    node.right		,	start - (node.map_left[start - 1] if start else 0)		,	end - node.map_left[end]		,	a		,	a		,	)
			return left + right


if __name__ == "__main__":
							import doctest

							doctest.testmod()