



def 			UpperCamelCase(  __UpperCamelCase							:		List[Any] ):
		# if the collection is empty, returns empty
		if collection == []:
				return []

		# get some information about the collection
		lowerCAmelCase_			:     List[Any]									= len(__UpperCamelCase )
		lowerCAmelCase_			:     Any									= max(__UpperCamelCase )
		lowerCAmelCase_			:     str									= min(__UpperCamelCase )

		# create the counting array
		lowerCAmelCase_			:     Union[str, Any]									= coll_max + 1 - coll_min
		lowerCAmelCase_			:     List[str]									= [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 ):
				lowerCAmelCase_			:     Optional[Any]									= counting_arr[i] + counting_arr[i - 1]

		# create the output collection
		lowerCAmelCase_			:     List[str]									= [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 ) ):
				lowerCAmelCase_			:     Dict									= collection[i]
				counting_arr[collection[i] - coll_min] -= 1

		return ordered


def 			UpperCamelCase(  __UpperCamelCase							:		Dict ):
		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"

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










'''simple docstring'''






from math import cos, sin, sqrt, tau

from audio_filters.iir_filter import IIRFilter


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )  )      ->   IIRFilter:
							UpperCAmelCase :       Optional[int] 							=		tau * frequency / samplerate
							UpperCAmelCase :       List[Any] 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       Optional[Any] 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       int 							=		_sin / (2 * q_factor)

							UpperCAmelCase :       Any 							=		(1 - _cos) / 2
							UpperCAmelCase :       List[Any] 							=		1 - _cos

							UpperCAmelCase :       Union[str, Any] 							=		1 + alpha
							UpperCAmelCase :       Any 							=		-2 * _cos
							UpperCAmelCase :       Dict 							=		1 - alpha

							UpperCAmelCase :       Union[str, Any] 							=		IIRFilter(2  )
							filt.set_coefficients([aa, aa, aa]   ,      [ba, ba, ba]  )
							return filt


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )  )      ->   IIRFilter:
							UpperCAmelCase :       Any 							=		tau * frequency / samplerate
							UpperCAmelCase :       Tuple 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       Tuple 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       Dict 							=		_sin / (2 * q_factor)

							UpperCAmelCase :       int 							=		(1 + _cos) / 2
							UpperCAmelCase :       List[Any] 							=		-1 - _cos

							UpperCAmelCase :       Tuple 							=		1 + alpha
							UpperCAmelCase :       List[str] 							=		-2 * _cos
							UpperCAmelCase :       Optional[Any] 							=		1 - alpha

							UpperCAmelCase :       Tuple 							=		IIRFilter(2  )
							filt.set_coefficients([aa, aa, aa]   ,      [ba, ba, ba]  )
							return filt


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )  )      ->   IIRFilter:
							UpperCAmelCase :       Optional[int] 							=		tau * frequency / samplerate
							UpperCAmelCase :       Optional[int] 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       Tuple 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       Optional[int] 							=		_sin / (2 * q_factor)

							UpperCAmelCase :       Union[str, Any] 							=		_sin / 2
							UpperCAmelCase :       Any 							=		0
							UpperCAmelCase :       int 							=		-ba

							UpperCAmelCase :       Optional[Any] 							=		1 + alpha
							UpperCAmelCase :       List[Any] 							=		-2 * _cos
							UpperCAmelCase :       Optional[Any] 							=		1 - alpha

							UpperCAmelCase :       int 							=		IIRFilter(2  )
							filt.set_coefficients([aa, aa, aa]   ,      [ba, ba, ba]  )
							return filt


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )  )      ->   IIRFilter:
							UpperCAmelCase :       List[str] 							=		tau * frequency / samplerate
							UpperCAmelCase :       Union[str, Any] 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       str 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       Optional[Any] 							=		_sin / (2 * q_factor)

							UpperCAmelCase :       List[str] 							=		1 - alpha
							UpperCAmelCase :       Any 							=		-2 * _cos
							UpperCAmelCase :       Optional[int] 							=		1 + alpha

							UpperCAmelCase :       Union[str, Any] 							=		IIRFilter(2  )
							filt.set_coefficients([ba, ba, ba]   ,      [ba, ba, ba]  )
							return filt


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )   ,      )      ->   IIRFilter:
							UpperCAmelCase :       Optional[Any] 							=		tau * frequency / samplerate
							UpperCAmelCase :       Union[str, Any] 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       Optional[int] 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       Dict 							=		_sin / (2 * q_factor)
							UpperCAmelCase :       str 							=		10 ** (gain_db / 40)

							UpperCAmelCase :       int 							=		1 + alpha * big_a
							UpperCAmelCase :       Union[str, Any] 							=		-2 * _cos
							UpperCAmelCase :       Optional[Any] 							=		1 - alpha * big_a
							UpperCAmelCase :       Union[str, Any] 							=		1 + alpha / big_a
							UpperCAmelCase :       Tuple 							=		-2 * _cos
							UpperCAmelCase :       Any 							=		1 - alpha / big_a

							UpperCAmelCase :       Optional[Any] 							=		IIRFilter(2  )
							filt.set_coefficients([aa, aa, aa]   ,      [ba, ba, ba]  )
							return filt


def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )   ,      )      ->   IIRFilter:
							UpperCAmelCase :       Any 							=		tau * frequency / samplerate
							UpperCAmelCase :       Optional[int] 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       Union[str, Any] 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       str 							=		_sin / (2 * q_factor)
							UpperCAmelCase :       List[str] 							=		10 ** (gain_db / 40)
							UpperCAmelCase :       Optional[int] 							=		(big_a + 1) - (big_a - 1) * _cos
							UpperCAmelCase :       int 							=		(big_a + 1) + (big_a - 1) * _cos
							UpperCAmelCase :       int 							=		(big_a - 1) - (big_a + 1) * _cos
							UpperCAmelCase :       Optional[int] 							=		(big_a - 1) + (big_a + 1) * _cos
							UpperCAmelCase :       str 							=		2 * sqrt(_lowerCAmelCase  ) * alpha

							UpperCAmelCase :       Dict 							=		big_a * (pmc + aaa)
							UpperCAmelCase :       Any 							=		2 * big_a * mpc
							UpperCAmelCase :       Union[str, Any] 							=		big_a * (pmc - aaa)
							UpperCAmelCase :       Optional[int] 							=		ppmc + aaa
							UpperCAmelCase :       Optional[Any] 							=		-2 * pmpc
							UpperCAmelCase :       Optional[Any] 							=		ppmc - aaa

							UpperCAmelCase :       int 							=		IIRFilter(2  )
							filt.set_coefficients([aa, aa, aa]   ,      [ba, ba, ba]  )
							return filt




def  snake_case_     (					_lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						int   ,      _lowerCAmelCase  :						float   ,      _lowerCAmelCase  :						float = 1 / sqrt(2  )   ,      )      ->   IIRFilter:
							UpperCAmelCase :       int 							=		tau * frequency / samplerate
							UpperCAmelCase :       Union[str, Any] 							=		sin(_lowerCAmelCase  )
							UpperCAmelCase :       Union[str, Any] 							=		cos(_lowerCAmelCase  )
							UpperCAmelCase :       Any 							=		_sin / (2 * q_factor)
							UpperCAmelCase :       int 							=		10 ** (gain_db / 40)
							UpperCAmelCase :       List[str] 							=		(big_a + 1) - (big_a - 1) * _cos
							UpperCAmelCase :       Union[str, Any] 							=		(big_a + 1) + (big_a - 1) * _cos
							UpperCAmelCase :       Optional[Any] 							=		(big_a - 1) - (big_a + 1) * _cos
							UpperCAmelCase :       Union[str, Any] 							=		(big_a - 1) + (big_a + 1) * _cos
							UpperCAmelCase :       List[str] 							=		2 * sqrt(_lowerCAmelCase  ) * alpha

							UpperCAmelCase :       Any 							=		big_a * (ppmc + aaa)
							UpperCAmelCase :       str 							=		-2 * big_a * pmpc
							UpperCAmelCase :       List[Any] 							=		big_a * (ppmc - aaa)
							UpperCAmelCase :       Optional[Any] 							=		pmc + aaa
							UpperCAmelCase :       Any 							=		2 * mpc
							UpperCAmelCase :       str 							=		pmc - aaa

							UpperCAmelCase :       Union[str, Any] 							=		IIRFilter(2  )
							filt.set_coefficients([aa, aa, aa]   ,      [ba, ba, ba]  )
							return filt





