code: 
  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())
  
  
style_context: 
  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()