"""simple docstring"""






import math
from itertools import permutations

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

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:int		,			_SCREAMING_SNAKE_CASE	:list  )				-> bool:
						a_		,					a_							:			Union[str, Any]     		=					0, len(_SCREAMING_SNAKE_CASE  ) - 1
						while left <= right:
												a_							:			List[Any]     		=					(left + right) // 2
												if prime_list[middle] == target:
																		return True
												elif prime_list[middle] < target:
																		a_							:			int     		=					middle + 1
												else:
																		a_							:			Any     		=					middle - 1

						return False

def  lowerCAmelCase_      ()				-> Optional[int]:
						a_							:			Tuple     		=					[n for n in range(1001		,			10000		,			2  ) if is_prime(_SCREAMING_SNAKE_CASE  )]
						a_							:			Optional[Any]     		=					[]

						for number in prime_list:
												a_							:			int     		=					[]

												for prime_member in permutations(list(str(_SCREAMING_SNAKE_CASE  )  )  ):
																		a_							:			Union[str, Any]     		=					int("".join(_SCREAMING_SNAKE_CASE  )  )

																		if prime % 2 == 0:
																								continue

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

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

						a_							:			Dict     		=					[]
						for candidate in candidates:
												a_							:			List[Any]     		=					len(_SCREAMING_SNAKE_CASE  )
												a_							:			List[Any]     		=					False

												for i in range(_SCREAMING_SNAKE_CASE  ):
																		for j in range(i + 1		,			_SCREAMING_SNAKE_CASE  ):
																								for k in range(j + 1		,			_SCREAMING_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]]  )  )
																																				a_							:			Any     		=					True

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

						a_							:			Any     		=					set()
						for seq in passed:
												answer.add("".join([str(_SCREAMING_SNAKE_CASE  ) for i in seq]  )  )

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


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





"""simple docstring"""






def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:int  )				-> Optional[int]:
						a_							:			List[Any]     		=					len(_SCREAMING_SNAKE_CASE  )
						for _ in range(
						    0		,			int(((no_of_elements - 1) / 2) + 1  )  ):  # we don't need to traverse to end of list as
												for j in range(0		,			no_of_elements - 1  ):
																		if (
																		    lst[j + 1] < lst[j]
																		):  # applying bubble sort algorithm from left to right (or forwards)
																								a_							:			List[str]     		=					lst[j + 1]
																								a_							:			Optional[Any]     		=					lst[j]
																								a_							:			Optional[Any]     		=					temp
																		if (
																		    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
																		):  # applying bubble sort algorithm from right to left (or backwards)
																								a_							:			Dict     		=					lst[no_of_elements - 1 - j]
																								a_							:			Dict     		=					lst[no_of_elements - 2 - j]
																								a_							:			Any     		=					temp
						return lst


if __name__ == "__main__":
				print('enter the list to be sorted')
				UpperCamelCase     					=     [int(x) for x in input().split()]  # inputing elements of the list in one line
				UpperCamelCase     					=     double_sort(lst)
				print('the sorted list is')
				print(sorted_lst)




