

import logging
import os
import sys
import threading
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


lowerCAmelCase_	     =     threading.Lock()
lowerCAmelCase_	     =     None

lowerCAmelCase_	     =     {
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

lowerCAmelCase_	     =     logging.WARNING

lowerCAmelCase_	     =     True





def   __SCREAMING_SNAKE_CASE ():
						snake_case_       =     os.getenv('''DIFFUSERS_VERBOSITY'''  ,		SCREAMING_SNAKE_CASE_	)
						if env_level_str:
												if env_level_str in log_levels:
																		return log_levels[env_level_str]
												else:
																		logging.getLogger().warning(
																		    F'''Unknown option DIFFUSERS_VERBOSITY={env_level_str}, '''
																		    F'''has to be one of: { ', '.join(log_levels.keys()	) }'''	)
						return _default_log_level





def   __SCREAMING_SNAKE_CASE ():
						return __name__.split('''.'''	)[0]





def   __SCREAMING_SNAKE_CASE ():
						return logging.getLogger(_get_library_name()	)





def   __SCREAMING_SNAKE_CASE ():
						global _default_handler

						with _lock:
												if _default_handler:
																		# This library has already configured the library root logger.
																		return
												snake_case_       =     logging.StreamHandler()  # Set sys.stderr as stream.
												snake_case_       =     sys.stderr.flush

												# Apply our default configuration to the library root logger.
												snake_case_       =     _get_library_root_logger()
												library_root_logger.addHandler(_default_handler	)
												library_root_logger.setLevel(_get_default_logging_level()	)
												snake_case_       =     False





def   __SCREAMING_SNAKE_CASE ():
						global _default_handler

						with _lock:
												if not _default_handler:
																		return

												snake_case_       =     _get_library_root_logger()
												library_root_logger.removeHandler(_default_handler	)
												library_root_logger.setLevel(logging.NOTSET	)
												snake_case_       =     None





def   __SCREAMING_SNAKE_CASE ():
						return log_levels





def   __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__ = None	):

						if name is None:
												snake_case_       =     _get_library_name()

						_configure_library_root_logger()
						return logging.getLogger(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						_configure_library_root_logger()
						return _get_library_root_logger().getEffectiveLevel()





def   __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__	):
						_configure_library_root_logger()
						_get_library_root_logger().setLevel(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						return set_verbosity(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						return set_verbosity(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						return set_verbosity(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						return set_verbosity(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						_configure_library_root_logger()

						assert _default_handler is not None
						_get_library_root_logger().removeHandler(_default_handler	)





def   __SCREAMING_SNAKE_CASE ():
						_configure_library_root_logger()

						assert _default_handler is not None
						_get_library_root_logger().addHandler(_default_handler	)





def   __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__	):
						_configure_library_root_logger()

						assert handler is not None
						_get_library_root_logger().addHandler(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__	):
						_configure_library_root_logger()

						assert handler is not None and handler not in _get_library_root_logger().handlers
						_get_library_root_logger().removeHandler(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						_configure_library_root_logger()
						snake_case_       =     False





def   __SCREAMING_SNAKE_CASE ():
						_configure_library_root_logger()
						snake_case_       =     True





def   __SCREAMING_SNAKE_CASE ():
						snake_case_       =     _get_library_root_logger().handlers

						for handler in handlers:
												snake_case_       =     logging.Formatter('''[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s'''	)
												handler.setFormatter(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE ():
						snake_case_       =     _get_library_root_logger().handlers

						for handler in handlers:
												handler.setFormatter(SCREAMING_SNAKE_CASE_	)





def   __SCREAMING_SNAKE_CASE (self  ,		*SCREAMING_SNAKE_CASE__  ,		**SCREAMING_SNAKE_CASE__	):
						snake_case_       =     os.getenv('''DIFFUSERS_NO_ADVISORY_WARNINGS'''  ,		SCREAMING_SNAKE_CASE_	)
						if no_advisory_warnings:
												return
						self.warning(*SCREAMING_SNAKE_CASE_  ,		**SCREAMING_SNAKE_CASE_	)


lowerCAmelCase_	     =     warning_advice





class      snake_case_       :







			'''simple docstring'''

			def __init__(					self			:    Optional[Any]							,       *_UpperCamelCase			:    Tuple							,       **_UpperCamelCase			:    Any							)				->Tuple:  # pylint: disable=unused-argument
									snake_case_       =     args[0] if args else None







			def __iter__(					self			:    Optional[Any]							)				->List[Any]:
									return iter(self._iterator							)







			def __getattr__(					self			:    int							,       _UpperCamelCase			:    int							)				->Optional[int]:






									def empty_fn(*_UpperCamelCase			:    Optional[int]							,       **_UpperCamelCase			:    Tuple							):  # pylint: disable=unused-argument
															return

									return empty_fn







			def __enter__(					self			:    Optional[Any]							)				->Any:
									return self







			def __exit__(					self			:    int							,       _UpperCamelCase			:    Optional[Any]							,       _UpperCamelCase			:    Optional[int]							,       _UpperCamelCase			:    Tuple							)				->Union[str, Any]:
									return






class      snake_case_       :







			'''simple docstring'''

			def __call__(					self			:    Tuple							,       *_UpperCamelCase			:    List[str]							,       **_UpperCamelCase			:    Any							)				->int:






									if _tqdm_active:
															return tqdm_lib.tqdm(*lowercase__							,       **lowercase__							)
									else:
															return EmptyTqdm(*lowercase__							,       **lowercase__							)







			def     snake_case__(					self			:    Any							,       *_UpperCamelCase			:    Any							,       **_UpperCamelCase			:    str							)				->List[Any]:
									snake_case_       =     None
									if _tqdm_active:
															return tqdm_lib.tqdm.set_lock(*lowercase__							,       **lowercase__							)







			def     snake_case__(					self			:    str							)				->str:






									if _tqdm_active:
															return tqdm_lib.tqdm.get_lock()






lowerCAmelCase_	     =     _tqdm_cls()





def   __SCREAMING_SNAKE_CASE ():
						global _tqdm_active
						return bool(_tqdm_active	)





def   __SCREAMING_SNAKE_CASE ():
						global _tqdm_active
						snake_case_       =     True





def   __SCREAMING_SNAKE_CASE ():
						global _tqdm_active
						snake_case_       =     False


from __future__ import annotations

from random import randrange


def   __SCREAMING_SNAKE_CASE (SCREAMING_SNAKE_CASE__	):
						if len(SCREAMING_SNAKE_CASE__	) < 2:
												return collection
						snake_case_       =     randrange(len(SCREAMING_SNAKE_CASE__	)	)  # Use random element as pivot
						snake_case_       =     collection[pivot_index]
						snake_case_       =     []  # All elements greater than pivot
						snake_case_       =     []  # All elements less than or equal to pivot

						for element in collection[:pivot_index]:
												(greater if element > pivot else lesser).append(SCREAMING_SNAKE_CASE__	)

						for element in collection[pivot_index + 1 :]:
												(greater if element > pivot else lesser).append(SCREAMING_SNAKE_CASE__	)

						return [*quick_sort(SCREAMING_SNAKE_CASE__	), pivot, *quick_sort(SCREAMING_SNAKE_CASE__	)]


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