code: 
  """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())
  
  
style_context: 
  """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()))}''')
  
  