'''simple docstring'''


import mpmath  # for roots of unity
import numpy as np






class 						SCREAMING_SNAKE_CASE_   :





							def __init__(      self				:							str     ,		__a				:							Optional[Any]=None     ,		__a				:							int=None	)							->	str:
								# Input as list
								__UpperCAmelCase							=			list(poly_a or [0]	)[:]
								__UpperCAmelCase							=			list(poly_b or [0]	)[:]

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

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

								# Add 0 to make lengths equal a power of 2
								__UpperCAmelCase							=			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
								__UpperCAmelCase							=			complex(mpmath.root(x=1     ,		n=self.c_max_length     ,		k=1	)	)

								# The product
								__UpperCAmelCase							=			self.__multiply()





							def       snake_case__						(      self				:							Optional[int]     ,		__a				:							Optional[int]	)							->	Any:
								__UpperCAmelCase							=			[[x] for x in self.polyA] if which == 'A' else [[x] for x in self.polyB]
								# Corner case
								if len(UpperCamelCase__	) <= 1:
									return dft[0]
								#
								__UpperCAmelCase							=			self.c_max_length // 2
								while next_ncol > 0:
									__UpperCAmelCase							=			[[] for i in range(UpperCamelCase__	)]
									__UpperCAmelCase							=			self.root**next_ncol

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





							def       snake_case__						(      self				:							Optional[Any]	)							->	Any:
								__UpperCAmelCase							=			self.__dft('''A'''	)
								__UpperCAmelCase							=			self.__dft('''B'''	)
								__UpperCAmelCase							=			[[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
								__UpperCAmelCase							=			2
								while next_ncol <= self.c_max_length:
									__UpperCAmelCase							=			[[] for i in range(UpperCamelCase__	)]
									__UpperCAmelCase							=			self.root ** (next_ncol // 2)
									__UpperCAmelCase							=			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
									__UpperCAmelCase							=			new_inverse_c
									next_ncol *= 2
								# Unpack
								__UpperCAmelCase							=			[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				:							Tuple	)							->	List[Any]:
								__UpperCAmelCase							=			'A = ' + ' + '.join(
								    f"""{coef}*x^{i}""" for coef, i in enumerate(self.polyA[: self.len_A]	)	)
								__UpperCAmelCase							=			'B = ' + ' + '.join(
								    f"""{coef}*x^{i}""" for coef, i in enumerate(self.polyB[: self.len_B]	)	)
								__UpperCAmelCase							=			'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()

'''simple docstring'''


def       lowerCAmelCase					(		UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	# if the collection is empty, returns empty
	if collection == []:
		return []

	# get some information about the collection
	__UpperCAmelCase							=			len(UpperCamelCase__       )
	__UpperCAmelCase							=			max(UpperCamelCase__       )
	__UpperCAmelCase							=			min(UpperCamelCase__       )

	# create the counting array
	__UpperCAmelCase							=			coll_max + 1 - coll_min
	__UpperCAmelCase							=			[0] * counting_arr_length

	# count how much a number appears in the collection
	for number in collection:
		counting_arr[number - coll_min] += 1

	# sum each position with it's predecessors. now, counting_arr[i] tells
	# us how many elements <= i has in the collection
	for i in range(1    ,					UpperCamelCase__       ):
		__UpperCAmelCase							=			counting_arr[i] + counting_arr[i - 1]

	# create the output collection
	__UpperCAmelCase							=			[0] * coll_len

	# place the elements in the output, respecting the original order (stable
	# sort) from end to begin, updating counting_arr
	for i in reversed(range(0    ,					UpperCamelCase__       )       ):
		__UpperCAmelCase							=			collection[i]
		counting_arr[collection[i] - coll_min] -= 1

	return ordered





def       lowerCAmelCase					(		UpperCamelCase__				:   Any       ):


	"""simple docstring"""
	return "".join([chr(UpperCamelCase__       ) for i in counting_sort([ord(UpperCamelCase__       ) for c in string]       )]       )


if __name__ == "__main__":
					# Test string sort
					assert counting_sort_string("thisisthestring") == "eghhiiinrsssttt"

					__lowerCAmelCase	:       str						       =	input("Enter numbers separated by a comma:\n").strip()
					__lowerCAmelCase	:       List[Any]						       =	[int(item) for item in user_input.split(",")]
					print(counting_sort(unsorted))
