from __future__ import annotations

from collections.abc import MutableSequence





class 	__lowercase    :




				'''simple docstring'''


				def __init__(		self    :		Tuple      ,							_a    :		int      ,							_a    :		Tuple				):
								if len(A__				) != degree + 1:
												raise ValueError(
												    '''The number of coefficients should be equal to the degree + 1.'''				)

								UpperCamelCase__					=				list(A__				)
								UpperCamelCase__					=				degree





				def __add__(		self    :		str      ,							_a    :		Dict				):

								if self.degree > polynomial_a.degree:
												UpperCamelCase__					=				self.coefficients[:]
												for i in range(polynomial_a.degree + 1				):
																coefficients[i] += polynomial_a.coefficients[i]
												return Polynomial(self.degree      ,							A__				)
								else:
												UpperCamelCase__					=				polynomial_a.coefficients[:]
												for i in range(self.degree + 1				):
																coefficients[i] += self.coefficients[i]
												return Polynomial(polynomial_a.degree      ,							A__				)





				def __sub__(		self    :		List[Any]      ,							_a    :		str				):
								return self + polynomial_a * Polynomial(0      ,							[-1]				)





				def __neg__(		self    :		int				):
								return Polynomial(self.degree      ,							[-c for c in self.coefficients]				)





				def __mul__(		self    :		int      ,							_a    :		Optional[Any]				):
								UpperCamelCase__					=				[0] * (self.degree + polynomial_a.degree + 1)
								for i in range(self.degree + 1				):
												for j in range(polynomial_a.degree + 1				):
																coefficients[i + j] += (
																    self.coefficients[i] * polynomial_a.coefficients[j]
																)

								return Polynomial(self.degree + polynomial_a.degree      ,							A__				)





				def      A_							(		self    :		Union[str, Any]      ,							_a    :		Optional[Any]				):
								UpperCamelCase__					=				0
								for i in range(self.degree + 1				):
												result += self.coefficients[i] * (substitution**i)
								return result





				def __str__(		self    :		Optional[Any]				):
								UpperCamelCase__					=				""""""
								for i in range(self.degree      ,							-1      ,							-1				):
												if self.coefficients[i] == 0:
																continue
												elif self.coefficients[i] > 0:
																if polynomial:
																				polynomial += " + "
												else:
																polynomial += " - "

												if i == 0:
																polynomial += str(abs(self.coefficients[i]				)				)
												elif i == 1:
																polynomial += str(abs(self.coefficients[i]				)				) + "x"
												else:
																polynomial += str(abs(self.coefficients[i]				)				) + "x^" + str(A__				)

								return polynomial





				def __repr__(		self    :		Tuple				):
								return self.__str__()





				def      A_							(		self    :		Optional[Any]				):
								UpperCamelCase__					=				[0] * self.degree
								for i in range(self.degree				):
												UpperCamelCase__					=				self.coefficients[i + 1] * (i + 1)
								return Polynomial(self.degree - 1      ,							A__				)





				def      A_							(		self    :		Union[str, Any]      ,							_a    :		int = 0				):
								UpperCamelCase__					=				[0] * (self.degree + 2)
								UpperCamelCase__					=				constant
								for i in range(self.degree + 1				):
												UpperCamelCase__					=				self.coefficients[i] / (i + 1)
								return Polynomial(self.degree + 1      ,							A__				)





				def __eq__(		self    :		str      ,							_a    :		Any				):
								if not isinstance(A__      ,							A__				):
												return False

								if self.degree != polynomial_a.degree:
												return False

								for i in range(self.degree + 1				):
												if self.coefficients[i] != polynomial_a.coefficients[i]:
																return False

								return True





				def __ne__(		self    :		Optional[Any]      ,							_a    :		Optional[Any]				):
								return not self.__eq__(A__				)






def 		UpperCamelCase   (lowercase_:					list   )	-> list:
	A__				:       Union[str, Any]	  =						False
	while is_sorted is False:  # Until all the indices are traversed keep looping
		A__				:       Dict	  =						True
		for i in range(0       , len(lowercase_   ) - 1       , 2   ):  # iterating over all even indices
			if input_list[i] > input_list[i + 1]:
				A__  ,  A__				:       Dict	  =						input_list[i + 1], input_list[i]
				# swapping if elements not in order
				A__				:       Optional[Any]	  =						False

		for i in range(1       , len(lowercase_   ) - 1       , 2   ):  # iterating over all odd indices
			if input_list[i] > input_list[i + 1]:
				A__  ,  A__				:       Dict	  =						input_list[i + 1], input_list[i]
				# swapping if elements not in order
				A__				:       Optional[Any]	  =						False
	return input_list


if __name__ == "__main__":
	print('Enter list to be sorted')
	A_			:					Optional[int]    			=     [int(x) for x in input().split()]
	# inputing elements of the list in one line
	A_			:					Optional[int]    			=     odd_even_sort(input_list)
	print('The sorted list is')
	print(sorted_list)



