code: 
  
  
  
  
  
  
  """simple docstring"""
  
  import math
  from itertools import permutations
  
  def 	__lowerCamelCase			(						__UpperCamelCase )		->					bool:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		if 1 < number < 4:
  				# 2 and 3 are primes
  				return True
  		elif number < 2 or number % 2 == 0 or number % 3 == 0:
  				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
  				return False
  
  		# All primes number are in format of 6k +/- 1
  		for i in range(5   , int(math.sqrt(__UpperCamelCase ) + 1 )   , 6 ):
  				if number % i == 0 or number % (i + 2) == 0:
  						return False
  		return True
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase )		->					bool:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_       ,			lowerCAmelCase_     :							Tuple             =    0, len(__UpperCamelCase ) - 1
  		while left <= right:
  				lowerCAmelCase_     :							Optional[int]             =    (left + right) // 2
  				if prime_list[middle] == target:
  						return True
  				elif prime_list[middle] < target:
  						lowerCAmelCase_     :							Any             =    middle + 1
  				else:
  						lowerCAmelCase_     :							List[Any]             =    middle - 1
  
  		return False
  
  def 	__lowerCamelCase			(						)		->					Tuple:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							List[str]             =    [n for n in range(1001   , 10000   , 2 ) if is_prime(__UpperCamelCase )]
  		lowerCAmelCase_     :							Optional[Any]             =    []
  
  		for number in prime_list:
  				lowerCAmelCase_     :							Union[str, Any]             =    []
  
  				for prime_member in permutations(list(str(__UpperCamelCase ) ) ):
  						lowerCAmelCase_     :							Tuple             =    int("".join(__UpperCamelCase ) )
  
  						if prime % 2 == 0:
  								continue
  
  						if search(__UpperCamelCase   , __UpperCamelCase ):
  								tmp_numbers.append(__UpperCamelCase )
  
  				tmp_numbers.sort()
  				if len(__UpperCamelCase ) >= 3:
  						candidates.append(__UpperCamelCase )
  
  		lowerCAmelCase_     :							List[str]             =    []
  		for candidate in candidates:
  				lowerCAmelCase_     :							str             =    len(__UpperCamelCase )
  				lowerCAmelCase_     :							List[Any]             =    False
  
  				for i in range(__UpperCamelCase ):
  						for j in range(i + 1   , __UpperCamelCase ):
  								for k in range(j + 1   , __UpperCamelCase ):
  										if (
  										    abs(candidate[i] - candidate[j] )
  										    == abs(candidate[j] - candidate[k] )
  										    and len({candidate[i], candidate[j], candidate[k]} ) == 3
  										):
  												passed.append(
  												    sorted([candidate[i], candidate[j], candidate[k]] ) )
  												lowerCAmelCase_     :							int             =    True
  
  										if found:
  												break
  								if found:
  										break
  						if found:
  								break
  
  		lowerCAmelCase_     :							Union[str, Any]             =    set()
  		for seq in passed:
  				answer.add("".join([str(__UpperCamelCase ) for i in seq] ) )
  
  		return max(int(__UpperCamelCase ) for x in answer )
  
  
  if __name__ == "__main__":
  					print(solution())
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_torch_available,
      is_vision_available,
  )
  
  
  lowercase__      =				{
      """configuration_mobilevitv2""": [
          """MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP""",
          """MobileViTV2Config""",
          """MobileViTV2OnnxConfig""",
      ],
  }
  
  
  try:
  					if not is_torch_available():
  										raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  					pass
  else:
  					lowercase__      =				[
  					    """MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
  					    """MobileViTV2ForImageClassification""",
  					    """MobileViTV2ForSemanticSegmentation""",
  					    """MobileViTV2Model""",
  					    """MobileViTV2PreTrainedModel""",
  					]
  
  if TYPE_CHECKING:
  					from .configuration_mobilevitva import (
  					    MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
  					    MobileViTVaConfig,
  					    MobileViTVaOnnxConfig,
  					)
  
  					try:
  										if not is_torch_available():
  															raise OptionalDependencyNotAvailable()
  					except OptionalDependencyNotAvailable:
  										pass
  					else:
  										from .modeling_mobilevitva import (
  										    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
  										    MobileViTVaForImageClassification,
  										    MobileViTVaForSemanticSegmentation,
  										    MobileViTVaModel,
  										    MobileViTVaPreTrainedModel,
  										)
  
  else:
  					import sys
  
  					lowercase__      =				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  