'''simple docstring'''




import math
from itertools import permutations





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> bool:

    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 	_UpperCAmelCase       (				_UpperCamelCase       :      int,  _UpperCamelCase       :      list  )      -> bool:
    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 	_UpperCAmelCase       (				)      -> Tuple:
    A_      =  [n for n in range(10_01,  1_00_00,  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'''




def 	_UpperCAmelCase       (				_UpperCamelCase       :      list[list[int]],  _UpperCamelCase       :      list[list[int]]  )      -> list[list[int]]:
    A_      =  []
    A_      =  len(_UpperCamelCase  )
    for i in range(_UpperCamelCase  ):
        A_      =  []
        for j in range(_UpperCamelCase  ):
            A_      =  0
            for k in range(_UpperCamelCase  ):
                A_      =  val + matrix_a[i][k] * matrix_b[k][j]
            list_a.append(_UpperCamelCase  )
        matrix_c.append(_UpperCamelCase  )
    return matrix_c





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> list[list[int]]:
    return [[int(row == column  ) for column in range(_UpperCamelCase  )] for row in range(_UpperCamelCase  )]





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> int:
    if n <= 1:
        return n
    A_      =  identity(2  )
    A_      =  [[1, 1], [1, 0]]
    A_      =  n - 1
    while n > 0:
        if n % 2 == 1:
            A_      =  multiply(_UpperCamelCase,  _UpperCamelCase  )
        A_      =  multiply(_UpperCamelCase,  _UpperCamelCase  )
        A_      =  int(n / 2  )
    return res_matrix[0][0]





def 	_UpperCAmelCase       (				_UpperCamelCase       :      int  )      -> int:
    if n <= 1:
        return n
    A_      =  0
    A_      =  1
    for _ in range(2,  n + 1  ):
        A_  ,A_      =  fiba, fiba + fiba
    return fiba





def 	_UpperCAmelCase       (				)      -> None:
    for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
        A_      =  int(''''''.join(c for c in ordinal if c in '''0123456789'''  )  )  # 1000th --> 1000
        print(
            F'''{ordinal} fibonacci number using matrix exponentiation is '''
            F'''{nth_fibonacci_matrix(_UpperCamelCase  )} and using bruteforce is '''
            F'''{nth_fibonacci_bruteforce(_UpperCamelCase  )}\n'''  )
    # from timeit import timeit
    # print(timeit("nth_fibonacci_matrix(1000000)",
    #              "from main import nth_fibonacci_matrix", number=5))
    # print(timeit("nth_fibonacci_bruteforce(1000000)",
    #              "from main import nth_fibonacci_bruteforce", number=5))
    # 2.3342058970001744
    # 57.256506615000035


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()






