code: 
  
  
  
  
  
  '''simple docstring'''
  
  from __future__ import annotations
  
  from collections import Counter
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->list[int]:
      _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      , __lowerCamelCase      , 2					):
          if is_prime[i]:
              primes.append(__lowerCamelCase					)
  
      return primes
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int					)		->list[list[int]]:
      _SCREAMING_SNAKE_CASE             =    str(__lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    []
      _SCREAMING_SNAKE_CASE             =    ["""0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9"""]
  
      for duplicate in Counter(__lowerCamelCase					) - Counter(set(__lowerCamelCase					)					):
          _SCREAMING_SNAKE_CASE             =    [int(number_str.replace(__lowerCamelCase      , __lowerCamelCase					)					) for digit in digits]
          replacements.append(__lowerCamelCase					)
  
      return replacements
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int = 8					)		->int:
      _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(__lowerCamelCase					)					) - len(set(str(__lowerCamelCase					)					)					) >= 3
      }
  
      for prime in primes:
          if prime in numbers_checked:
              continue
  
          _SCREAMING_SNAKE_CASE             =    digit_replacements(__lowerCamelCase					)
  
          for family in replacements:
              numbers_checked.update(__lowerCamelCase					)
              _SCREAMING_SNAKE_CASE             =    primes.intersection(__lowerCamelCase					)
  
              if len(__lowerCamelCase					) != family_length:
                  continue
  
              return min(__lowerCamelCase					)
  
      return -1
  
  
  if __name__ == "__main__":
        print(solution())
  
  
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  def lowerCamelCase		(  __lowerCamelCase				:					float      , __lowerCamelCase				:					float      , __lowerCamelCase				:					float					)		->list[int]:
      if hue < 0 or hue > 360:
          raise Exception("""hue should be between 0 and 360"""					)
  
      if saturation < 0 or saturation > 1:
          raise Exception("""saturation should be between 0 and 1"""					)
  
      if value < 0 or value > 1:
          raise Exception("""value should be between 0 and 1"""					)
  
      _SCREAMING_SNAKE_CASE             =    value * saturation
      _SCREAMING_SNAKE_CASE             =    hue / 60
      _SCREAMING_SNAKE_CASE             =    chroma * (1 - abs(hue_section % 2 - 1					))
      _SCREAMING_SNAKE_CASE             =    value - chroma
  
      if hue_section >= 0 and hue_section <= 1:
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
      elif hue_section > 1 and hue_section <= 2:
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
      elif hue_section > 2 and hue_section <= 3:
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
      elif hue_section > 3 and hue_section <= 4:
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
      elif hue_section > 4 and hue_section <= 5:
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
      else:
          _SCREAMING_SNAKE_CASE             =    round(255 * (chroma + match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (match_value)					)
          _SCREAMING_SNAKE_CASE             =    round(255 * (second_largest_component + match_value)					)
  
      return [red, green, blue]
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					int      , __lowerCamelCase				:					int      , __lowerCamelCase				:					int					)		->list[float]:
      if red < 0 or red > 255:
          raise Exception("""red should be between 0 and 255"""					)
  
      if green < 0 or green > 255:
          raise Exception("""green should be between 0 and 255"""					)
  
      if blue < 0 or blue > 255:
          raise Exception("""blue should be between 0 and 255"""					)
  
      _SCREAMING_SNAKE_CASE             =    red / 255
      _SCREAMING_SNAKE_CASE             =    green / 255
      _SCREAMING_SNAKE_CASE             =    blue / 255
      _SCREAMING_SNAKE_CASE             =    max(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    value - min(__lowerCamelCase      , __lowerCamelCase      , __lowerCamelCase					)
      _SCREAMING_SNAKE_CASE             =    0 if value == 0 else chroma / value
  
      if chroma == 0:
          _SCREAMING_SNAKE_CASE             =    0.0
      elif value == float_red:
          _SCREAMING_SNAKE_CASE             =    60 * (0 + (float_green - float_blue) / chroma)
      elif value == float_green:
          _SCREAMING_SNAKE_CASE             =    60 * (2 + (float_blue - float_red) / chroma)
      else:
          _SCREAMING_SNAKE_CASE             =    60 * (4 + (float_red - float_green) / chroma)
  
      _SCREAMING_SNAKE_CASE             =    (hue + 360) % 360
  
      return [hue, saturation, value]
  
  
  
  
  
  
  def lowerCamelCase		(  __lowerCamelCase				:					list[float]      , __lowerCamelCase				:					list[float]					)		->bool:
      _SCREAMING_SNAKE_CASE             =    abs(hsv_a[0] - hsv_a[0]					) < 0.2
      _SCREAMING_SNAKE_CASE             =    abs(hsv_a[1] - hsv_a[1]					) < 0.002
      _SCREAMING_SNAKE_CASE             =    abs(hsv_a[2] - hsv_a[2]					) < 0.002
  
      return check_hue and check_saturation and check_value
  
  
  
  