
'''simple docstring'''
from __future__ import annotations







def 							A_  (    __SCREAMING_SNAKE_CASE    :	str      ,  __SCREAMING_SNAKE_CASE    :	Tuple      ,  __SCREAMING_SNAKE_CASE    :	Union[str, Any]			)					->							str:





  """simple docstring"""

  assert (
      c % greatest_common_divisor(_UpperCAmelCase      ,  _UpperCAmelCase			) == 0
  )  # greatest_common_divisor(a,b) function implemented below
  ((__A)				,       (__A)				,       (__A))		:  List[Any]       				=		extended_gcd(_UpperCAmelCase      ,  _UpperCAmelCase			)  # extended_gcd(a,b) function implemented below
  __A		:  str       				=		c / d
  return (r * x, r * y)







def 							A_  (    __SCREAMING_SNAKE_CASE    :	Optional[Any]      ,  __SCREAMING_SNAKE_CASE    :	Tuple      ,  __SCREAMING_SNAKE_CASE    :	List[str]      ,  __SCREAMING_SNAKE_CASE    :	Any = 2			)					->							int:





  """simple docstring"""

  ((__A)				,       (__A))		:  Union[str, Any]       				=		diophantine(_UpperCAmelCase      ,  _UpperCAmelCase      ,  _UpperCAmelCase			)  # Initial value
  __A		:  Tuple       				=		greatest_common_divisor(_UpperCAmelCase      ,  _UpperCAmelCase			)
  __A		:  Any       				=		a // d
  __A		:  str       				=		b // d

  for i in range(_UpperCAmelCase			):
    __A		:  str       				=		xa + i * q
    __A		:  Any       				=		ya - i * p
    print(_UpperCAmelCase      ,  _UpperCAmelCase			)







def 							A_  (    __SCREAMING_SNAKE_CASE    :	Dict      ,  __SCREAMING_SNAKE_CASE    :	Optional[int]			)					->							List[Any]:





  """simple docstring"""

  if a < b:
    __A				,       __A		:  Union[str, Any]       				=		b, a

  while a % b != 0:
    __A				,       __A		:  List[str]       				=		b, a % b

  return b







def 							A_  (    __SCREAMING_SNAKE_CASE    :	str      ,  __SCREAMING_SNAKE_CASE    :	str			)					->							Union[str, Any]:





  """simple docstring"""

  assert a >= 0 and b >= 0

  if b == 0:
    __A				,       __A				,       __A		:  str       				=		a, 1, 0
  else:
    ((__A)				,       (__A)				,       (__A))		:  List[str]       				=		extended_gcd(_UpperCAmelCase      ,  a % b			)
    __A		:  Optional[int]       				=		q
    __A		:  Any       				=		p - q * (a // b)

  assert a % d == 0 and b % d == 0
  assert d == a * x + b * y

  return (d, x, y)


if __name__ == "__main__":
     from doctest import testmod

     testmod(name='diophantine', verbose=True)
     testmod(name='diophantine_all_soln', verbose=True)
     testmod(name='extended_gcd', verbose=True)
     testmod(name='greatest_common_divisor', verbose=True)








def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if right <= left:
										return
					lowercase						   =       lowercase						   =       left
					lowercase						   =       right
					lowercase						   =       sorting[left]
					while i <= b:
										if sorting[i] < pivot:
															lowercase   ,      lowercase						   =       sorting[i], sorting[a]
															a += 1
															i += 1
										elif sorting[i] > pivot:
															lowercase   ,      lowercase						   =       sorting[i], sorting[b]
															b -= 1
										else:
															i += 1
					quick_sort_apartition(_UpperCAmelCase       ,			_UpperCAmelCase       ,			a - 1				)
					quick_sort_apartition(_UpperCAmelCase       ,			b + 1       ,			_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					if left < right:
										lowercase						   =       lomuto_partition(_UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				)
										quick_sort_lomuto_partition(_UpperCAmelCase       ,			_UpperCAmelCase       ,			pivot_index - 1				)
										quick_sort_lomuto_partition(_UpperCAmelCase       ,			pivot_index + 1       ,			_UpperCAmelCase				)





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase				):
					"""simple docstring"""






					lowercase						   =       sorting[right]
					lowercase						   =       left
					for i in range(_UpperCAmelCase       ,			_UpperCAmelCase				):
										if sorting[i] < pivot:
															lowercase   ,      lowercase						   =       sorting[i], sorting[store_index]
															store_index += 1
					lowercase   ,      lowercase						   =       sorting[store_index], sorting[right]
					return store_index





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					if len(_UpperCAmelCase				) <= 1:
										return sorting
					return (
					    three_way_radix_quicksort([i for i in sorting if i < sorting[0]]				)
					    + [i for i in sorting if i == sorting[0]]
					    + three_way_radix_quicksort([i for i in sorting if i > sorting[0]]				)
					)


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)

		__magic_name__       =     input('''Enter numbers separated by a comma:\n''').strip()
		__magic_name__       =     [int(item) for item in user_input.split(''',''')]
		quick_sort_apartition(unsorted, 0, len(unsorted) - 1)
		print(unsorted)






