
"""simple docstring"""







import math
from itertools import permutations
def 			__UpperCAmelCase		(		a_			:		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(__lowerCamelCase				) + 1				)    ,  6				):
      if number % i == 0 or number % (i + 2) == 0:
         return False
   return True
def 			__UpperCAmelCase		(		a_			:		int    ,  a_			:		list				)     ->       bool:
   _UpperCAmelCase	,							_UpperCAmelCase   	=					0, len(__lowerCamelCase				) - 1
   while left <= right:
      _UpperCAmelCase   	=					(left + right) // 2
      if prime_list[middle] == target:
         return True
      elif prime_list[middle] < target:
         _UpperCAmelCase   	=					middle + 1
      else:
         _UpperCAmelCase   	=					middle - 1

   return False
def 			__UpperCAmelCase		(		)     ->       List[Any]:
   _UpperCAmelCase   	=					[n for n in range(10_01    ,  1_00_00    ,  2				) if is_prime(__lowerCamelCase				)]
   _UpperCAmelCase   	=					[]

   for number in prime_list:
      _UpperCAmelCase   	=					[]

      for prime_member in permutations(list(str(__lowerCamelCase				)				)				):
         _UpperCAmelCase   	=					int("".join(__lowerCamelCase				)				)

         if prime % 2 == 0:
            continue

         if search(__lowerCamelCase    ,  __lowerCamelCase				):
            tmp_numbers.append(__lowerCamelCase				)

      tmp_numbers.sort()
      if len(__lowerCamelCase				) >= 3:
         candidates.append(__lowerCamelCase				)

   _UpperCAmelCase   	=					[]
   for candidate in candidates:
      _UpperCAmelCase   	=					len(__lowerCamelCase				)
      _UpperCAmelCase   	=					False

      for i in range(__lowerCamelCase				):
         for j in range(i + 1    ,  __lowerCamelCase				):
            for k in range(j + 1    ,  __lowerCamelCase				):
               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]]				)				)
                  _UpperCAmelCase   	=					True

               if found:
                  break
            if found:
               break
         if found:
            break

   _UpperCAmelCase   	=					set()
   for seq in passed:
      answer.add("".join([str(__lowerCamelCase				) for i in seq]				)				)

   return max(int(__lowerCamelCase				) for x in answer				)


if __name__ == "__main__":
      print(solution())



"""simple docstring"""







from math import floor, sqrt
def 			__UpperCAmelCase		(		a_			:		int				)     ->       int:
   _UpperCAmelCase   	=					0.0
   _UpperCAmelCase   	=					1.0
   _UpperCAmelCase   	=					int(sqrt(a_				)				)
   _UpperCAmelCase   	=					root
   _UpperCAmelCase   	=					0
   while integer_part != 2 * root:
      _UpperCAmelCase   	=					denominator * integer_part - numerator
      _UpperCAmelCase   	=					(n - numerator**2) / denominator
      _UpperCAmelCase   	=					int((root + numerator) / denominator				)
      period += 1
   return period
def 			__UpperCAmelCase		(		a_			:		int = 1_00_00				)     ->       int:
   _UpperCAmelCase   	=					0
   for i in range(2    ,  n + 1				):
      _UpperCAmelCase   	=					sqrt(a_				)
      if sr - floor(a_				) != 0 and continuous_fraction_period(a_				) % 2 == 1:
         count_odd_periods += 1
   return count_odd_periods


if __name__ == "__main__":
  print(f'''{solution(int(input().strip()))}''')

