






import mpmath  # for roots of unity
import numpy as np



class 							SCREAMING_SNAKE_CASE__		:





					"""simple docstring"""






					def __init__(      self  :						Optional[int]							,	__A  :						int=None							,	__A  :						List[Any]=None ):
						# Input as list
						snake_case__				:   Optional[int]     =						list(poly_a or [0] )[:]
						snake_case__				:   Optional[int]     =						list(poly_b or [0] )[:]

						# Remove leading zero coefficients
						while self.polyA[-1] == 0:
							self.polyA.pop()
						snake_case__				:   Optional[int]     =						len(self.polyA )

						while self.polyB[-1] == 0:
							self.polyB.pop()
						snake_case__				:   Dict     =						len(self.polyB )

						# Add 0 to make lengths equal a power of 2
						snake_case__				:   Optional[Any]     =						int(
						    2 ** np.ceil(np.loga(len(self.polyA ) + len(self.polyB ) - 1 ) ) )

						while len(self.polyA ) < self.c_max_length:
							self.polyA.append(0 )
						while len(self.polyB ) < self.c_max_length:
							self.polyB.append(0 )
						# A complex root used for the fourier transform
						snake_case__				:   List[str]     =						complex(mpmath.root(x=1							,	n=self.c_max_length							,	k=1 ) )

						# The product
						snake_case__				:   List[Any]     =						self.__multiply()



					def  _lowercase  (      self  :						str							,	__A  :						str ):
						snake_case__				:   List[Any]     =						[[x] for x in self.polyA] if which == "A" else [[x] for x in self.polyB]
						# Corner case
						if len(__A ) <= 1:
							return dft[0]
						#
						snake_case__				:   Union[str, Any]     =						self.c_max_length // 2
						while next_ncol > 0:
							snake_case__				:   Dict     =						[[] for i in range(__A )]
							snake_case__				:   Optional[Any]     =						self.root**next_ncol

							# First half of next step
							snake_case__				:   Any     =						1
							for j in range(self.c_max_length // (next_ncol * 2) ):
								for i in range(__A ):
									new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j] )
								current_root *= root
							# Second half of next step
							snake_case__				:   str     =						1
							for j in range(self.c_max_length // (next_ncol * 2) ):
								for i in range(__A ):
									new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j] )
								current_root *= root
							# Update
							snake_case__				:   List[Any]     =						new_dft
							snake_case__				:   Dict     =						next_ncol // 2
						return dft[0]



					def  _lowercase  (      self  :						Optional[Any] ):
						snake_case__				:   Tuple     =						self.__dft("A" )
						snake_case__				:   int     =						self.__dft("B" )
						snake_case__				:   Optional[Any]     =						[[dft_a[i] * dft_b[i] for i in range(self.c_max_length )]]
						del dft_a
						del dft_b

						# Corner Case
						if len(inverce_c[0] ) <= 1:
							return inverce_c[0]
						# Inverse DFT
						snake_case__				:   str     =						2
						while next_ncol <= self.c_max_length:
							snake_case__				:   List[Any]     =						[[] for i in range(__A )]
							snake_case__				:   Any     =						self.root ** (next_ncol // 2)
							snake_case__				:   Tuple     =						1
							# First half of next step
							for j in range(self.c_max_length // next_ncol ):
								for i in range(next_ncol // 2 ):
									# Even positions
									new_inverse_c[i].append(
									    (
									        inverce_c[i][j]
									        + inverce_c[i][j + self.c_max_length // next_ncol]
									    )
									    / 2 )
									# Odd positions
									new_inverse_c[i + next_ncol // 2].append(
									    (
									        inverce_c[i][j]
									        - inverce_c[i][j + self.c_max_length // next_ncol]
									    )
									    / (2 * current_root) )
								current_root *= root
							# Update
							snake_case__				:   Dict     =						new_inverse_c
							next_ncol *= 2
						# Unpack
						snake_case__				:   List[str]     =						[round(x[0].real							,	8 ) + round(x[0].imag							,	8 ) * 1j for x in inverce_c]

						# Remove leading 0's
						while inverce_c[-1] == 0:
							inverce_c.pop()
						return inverce_c






					def __str__(      self  :						List[Any] ):
						snake_case__				:   Union[str, Any]     =						"A = " + " + ".join(
						    f'''{coef}*x^{i}''' for coef, i in enumerate(self.polyA[: self.len_A] ) )
						snake_case__				:   Optional[Any]     =						"B = " + " + ".join(
						    f'''{coef}*x^{i}''' for coef, i in enumerate(self.polyB[: self.len_B] ) )
						snake_case__				:   Tuple     =						"A*B = " + " + ".join(
						    f'''{coef}*x^{i}''' for coef, i in enumerate(self.product ) )

						return f'''{a}\n{b}\n{c}'''


# Unit tests
if __name__ == "__main__":
	import doctest

	doctest.testmod()











def   SCREAMING_SNAKE_CASE       (				snake_case_      :							list     ):
	if len(snake_case_     ) <= 1:
		return lst

	snake_case__				:   List[Any]     =						1

	while i < len(snake_case_     ):
		if lst[i - 1] <= lst[i]:
			i += 1
		else:
			snake_case__,		snake_case__				:   Tuple     =						lst[i], lst[i - 1]
			i -= 1
			if i == 0:
				snake_case__				:   Union[str, Any]     =						1

	return lst


if __name__ == "__main__":
	__lowerCamelCase      :    Dict   		=   input("""Enter numbers separated by a comma:\n""").strip()
	__lowerCamelCase      :    Tuple   		=   [int(item) for item in user_input.split(""",""")]
	print(gnome_sort(unsorted))



