


from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
lowerCAmelCase__						=			TypeVar('T', bound='Enum')







@unique
class 					lowerCAmelCase__	(    a):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE        =			80
     __SCREAMING_SNAKE_CASE        =			70
     __SCREAMING_SNAKE_CASE        =			60
     __SCREAMING_SNAKE_CASE        =			50
     __SCREAMING_SNAKE_CASE        =			40
     __SCREAMING_SNAKE_CASE        =			30
     __SCREAMING_SNAKE_CASE        =			20
     __SCREAMING_SNAKE_CASE        =			10







@unique
class 					lowerCAmelCase__	(    a):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE        =			24
     __SCREAMING_SNAKE_CASE        =			21
     __SCREAMING_SNAKE_CASE        =			18
     __SCREAMING_SNAKE_CASE        =			15
     __SCREAMING_SNAKE_CASE        =			12
     __SCREAMING_SNAKE_CASE        =			9
     __SCREAMING_SNAKE_CASE        =			6
     __SCREAMING_SNAKE_CASE        =			3
     __SCREAMING_SNAKE_CASE        =			2
     __SCREAMING_SNAKE_CASE        =			1
     __SCREAMING_SNAKE_CASE        =			-1
     __SCREAMING_SNAKE_CASE        =			-2
     __SCREAMING_SNAKE_CASE        =			-3
     __SCREAMING_SNAKE_CASE        =			-6
     __SCREAMING_SNAKE_CASE        =			-9
     __SCREAMING_SNAKE_CASE        =			-12
     __SCREAMING_SNAKE_CASE        =			-15
     __SCREAMING_SNAKE_CASE        =			-18
     __SCREAMING_SNAKE_CASE        =			-21
     __SCREAMING_SNAKE_CASE        =			-24


     @classmethod
     def 			_lowerCamelCase			(						cls)      ->    dict:
            return {unit.name: unit.value for unit in cls if unit.value > 0}


     @classmethod
     def 			_lowerCamelCase			(						cls)      ->    dict:
            return {unit.name: unit.value for unit in cls if unit.value < 0}




def 							_UpperCAmelCase    (UpperCamelCase__					:  float						):
       _A				:	List[str]       =			SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
       for name_prefix, value_prefix in prefixes.items():
              _A				:	List[str]       =			value / (10**value_prefix)
              if numerical_part > 1:
                     return f"{numerical_part!s} {name_prefix}"
       return str(UpperCamelCase__						)
def 							_UpperCAmelCase    (UpperCamelCase__					:  float						):
       for prefix in BinaryUnit:
              _A				:	Optional[Any]       =			value / (2**prefix.value)
              if numerical_part > 1:
                     return f"{numerical_part!s} {prefix.name}"
       return str(UpperCamelCase__						)


if __name__ == "__main__":
    import doctest

    doctest.testmod()




def 							_UpperCAmelCase    (UpperCamelCase__					:  list    ,							UpperCamelCase__					:  int    ,							UpperCamelCase__					:  int						):
       if right <= left:
              return
       _A				:	str       =			left
       _A				:	List[str]       =			right
       _A				:	Union[str, Any]       =			sorting[left]
       while i <= b:
              if sorting[i] < pivot:
                     _A   ,      _A				:	Union[str, Any]       =			sorting[i], sorting[a]
                     a += 1
                     i += 1
              elif sorting[i] > pivot:
                     _A   ,      _A				:	str       =			sorting[i], sorting[b]
                     b -= 1
              else:
                     i += 1
       quick_sort_apartition(UpperCamelCase__    ,							UpperCamelCase__    ,							a - 1						)
       quick_sort_apartition(UpperCamelCase__    ,							b + 1    ,							UpperCamelCase__						)
def 							_UpperCAmelCase    (UpperCamelCase__					:  list    ,							UpperCamelCase__					:  int    ,							UpperCamelCase__					:  int						):
       if left < right:
              _A				:	Tuple       =			lomuto_partition(UpperCamelCase__    ,							UpperCamelCase__    ,							UpperCamelCase__						)
              quick_sort_lomuto_partition(UpperCamelCase__    ,							UpperCamelCase__    ,							pivot_index - 1						)
              quick_sort_lomuto_partition(UpperCamelCase__    ,							pivot_index + 1    ,							UpperCamelCase__						)
def 							_UpperCAmelCase    (UpperCamelCase__					:  list    ,							UpperCamelCase__					:  int    ,							UpperCamelCase__					:  int						):
       _A				:	Tuple       =			sorting[right]
       _A				:	Tuple       =			left
       for i in range(UpperCamelCase__    ,							UpperCamelCase__						):
              if sorting[i] < pivot:
                     _A   ,      _A				:	int       =			sorting[i], sorting[store_index]
                     store_index += 1
       _A   ,      _A				:	Dict       =			sorting[store_index], sorting[right]
       return store_index
def 							_UpperCAmelCase    (UpperCamelCase__					:  list						):
       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)

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