


"""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())




"""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__       )
