




from math import floor, sqrt


def 				__SCREAMING_SNAKE_CASE    (     snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase						=	0.0
						_UpperCAmelCase						=	1.0
						_UpperCAmelCase						=	int(sqrt(snake_case_		)		)
						_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 				__SCREAMING_SNAKE_CASE    (     snake_case_ = 1_0000		):

						'''simple docstring'''


						_UpperCAmelCase						=	0
						for i in range(2      ,       n + 1		):
												_UpperCAmelCase						=	sqrt(snake_case_		)
												if sr - floor(snake_case_		) != 0 and continuous_fraction_period(snake_case_		) % 2 == 1:
																		count_odd_periods += 1
						return count_odd_periods


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










import math
from itertools import permutations


def 				__SCREAMING_SNAKE_CASE    (     snake_case_		):

						'''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(snake_case_		) + 1		)      ,       6		):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True


def 				__SCREAMING_SNAKE_CASE    (     snake_case_      ,       snake_case_		):

						'''simple docstring'''


						_UpperCAmelCase				,					_UpperCAmelCase						=	0, len(snake_case_		) - 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 				__SCREAMING_SNAKE_CASE    (     ):

						'''simple docstring'''


						_UpperCAmelCase						=	[n for n in range(1001      ,       1_0000      ,       2		) if is_prime(snake_case_		)]
						_UpperCAmelCase						=	[]

						for number in prime_list:
												_UpperCAmelCase						=	[]

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

																		if prime % 2 == 0:
																								continue

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

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

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

												for i in range(snake_case_		):
																		for j in range(i + 1      ,       snake_case_		):
																								for k in range(j + 1      ,       snake_case_		):
																														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(snake_case_		) for i in seq]		)		)

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


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




