code: 
  
  
  """simple docstring"""
  
  
  
  
  import math
  from itertools import permutations
  
  
  
  def 						__a      (  a					)     ->   Dict:
  
  
  
  
  
         """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 						__a      (  a,		a					)     ->   str:
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         _a   , _a          =				0, len(UpperCamelCase__					) - 1
         while left <= right:
                _a          =				(left + right) // 2
                if prime_list[middle] == target:
                       return True
                elif prime_list[middle] < target:
                       _a          =				middle + 1
                else:
                       _a          =				middle - 1
  
         return False
  
  
  
  def 						__a      (  )     ->   str:
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         _a          =				[n for n in range(1_0_0_1,		1_0_0_0_0,		2					) if is_prime(UpperCamelCase__					)]
         _a          =				[]
  
         for number in prime_list:
                _a          =				[]
  
                for prime_member in permutations(list(str(UpperCamelCase__					)					)					):
                       _a          =				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__					)
  
         _a          =				[]
         for candidate in candidates:
                _a          =				len(UpperCamelCase__					)
                _a          =				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]]					)					)
                                            _a          =				True
  
                                     if found:
                                            break
                              if found:
                                     break
                       if found:
                              break
  
         _a          =				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"""
  
  
  
  
  import warnings
  
  from ...utils import logging
  from .image_processing_vit import ViTImageProcessor
  
  
  __SCREAMING_SNAKE_CASE					=						logging.get_logger(__name__)
  
  
  
  
  
  class __snake_case		(					_SCREAMING_SNAKE_CASE      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     def __init__(		self							:Tuple				,  *UpperCamelCase__							:Tuple				,  **UpperCamelCase__							:Any       ):
            warnings.warn(
                "The class ViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"
                " use ViTImageProcessor instead."				,  UpperCamelCase__				,  )
            super().__init__(*UpperCamelCase__				,  **UpperCamelCase__       )
  