






import functools
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

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


UpperCamelCase			    =     threading.Lock()
UpperCamelCase			    =     None

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

UpperCamelCase			    =     logging.WARNING

UpperCamelCase			    =     True

def 	__lowerCamelCase      (		)							->  List[str]:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  os.getenv("""TRANSFORMERS_VERBOSITY"""	,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 TRANSFORMERS_VERBOSITY={env_level_str}, '
																		    F'has to be one of: { ", ".join(log_levels.keys()		) }'		)
						return _default_log_level

def 	__lowerCamelCase      (		)							->  str:






						"""simple docstring"""





						return __name__.split("""."""		)[0]

def 	__lowerCamelCase      (		)							->  logging.Logger:






						"""simple docstring"""





						return logging.getLogger(_get_library_name()		)

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						global _default_handler

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

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

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						global _default_handler

						with _lock:
												if not _default_handler:
																		return

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

def 	__lowerCamelCase      (		)							->  Optional[int]:






						"""simple docstring"""





						return log_levels

def 	__lowerCamelCase      (		snake_case__ = None		)							->  logging.Logger:






						"""simple docstring"""





						if name is None:
												_SCREAMING_SNAKE_CASE     				=  _get_library_name()

						_configure_library_root_logger()
						return logging.getLogger(snake_case__		)

def 	__lowerCamelCase      (		)							->  int:






						"""simple docstring"""





						_configure_library_root_logger()
						return _get_library_root_logger().getEffectiveLevel()

def 	__lowerCamelCase      (		snake_case__		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()
						_get_library_root_logger().setLevel(snake_case__		)

def 	__lowerCamelCase      (		)							->  str:






						"""simple docstring"""





						return set_verbosity(snake_case__		)

def 	__lowerCamelCase      (		)							->  Dict:






						"""simple docstring"""





						return set_verbosity(snake_case__		)

def 	__lowerCamelCase      (		)							->  List[Any]:






						"""simple docstring"""





						return set_verbosity(snake_case__		)

def 	__lowerCamelCase      (		)							->  Optional[Any]:






						"""simple docstring"""





						return set_verbosity(snake_case__		)

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()

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

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()

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

def 	__lowerCamelCase      (		snake_case__		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()

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

def 	__lowerCamelCase      (		snake_case__		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()

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

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()
						_SCREAMING_SNAKE_CASE     				=  False

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						_configure_library_root_logger()
						_SCREAMING_SNAKE_CASE     				=  True

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  _get_library_root_logger().handlers

						for handler in handlers:
												_SCREAMING_SNAKE_CASE     				=  logging.Formatter("""[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s"""		)
												handler.setFormatter(snake_case__		)

def 	__lowerCamelCase      (		)							->  None:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  _get_library_root_logger().handlers

						for handler in handlers:
												handler.setFormatter(snake_case__		)

def 	__lowerCamelCase      (		self	,*snake_case__	,**snake_case__		)							->  Optional[Any]:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  os.getenv("""TRANSFORMERS_NO_ADVISORY_WARNINGS"""	,snake_case__		)
						if no_advisory_warnings:
												return
						self.warning(*snake_case__	,**snake_case__		)


UpperCamelCase			    =     warning_advice

@functools.lru_cache(snake_case__		)
def 	__lowerCamelCase      (		self	,*snake_case__	,**snake_case__		)							->  str:






						"""simple docstring"""





						self.warning(*snake_case__	,**snake_case__		)


UpperCamelCase			    =     warning_once



class 				__UpperCAmelCase		:







			def __init__(     self:  Optional[int]				,     *UpperCAmelCase_:  Tuple				,     **UpperCAmelCase_:  int					):  # pylint: disable=unused-argument







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  args[0] if args else None







			def __iter__(     self:  Any					):







									'''simple docstring'''




									return iter(self._iterator					)







			def __getattr__(     self:  List[Any]				,     UpperCAmelCase_:  Union[str, Any]					):







									'''simple docstring'''




									def empty_fn(*UpperCAmelCase_:  Tuple				,     **UpperCAmelCase_:  str					):  # pylint: disable=unused-argument
															return

									return empty_fn







			def __enter__(     self:  str					):







									'''simple docstring'''




									return self







			def __exit__(     self:  Optional[int]				,     UpperCAmelCase_:  Optional[int]				,     UpperCAmelCase_:  str				,     UpperCAmelCase_:  Optional[Any]					):







									'''simple docstring'''




									return



class 				__UpperCAmelCase		:







			def __call__(     self:  Tuple				,     *UpperCAmelCase_:  List[Any]				,     **UpperCAmelCase_:  int					):







									'''simple docstring'''




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







			def 							UpperCamelCase				(     self:  Union[str, Any]				,     *UpperCAmelCase_:  Union[str, Any]				,     **UpperCAmelCase_:  Tuple					):







									'''simple docstring'''




									_SCREAMING_SNAKE_CASE     				=  None
									if _tqdm_active:
															return tqdm_lib.tqdm.set_lock(*UpperCAmelCase_				,     **UpperCAmelCase_					)







			def 							UpperCamelCase				(     self:  Any					):







									'''simple docstring'''




									if _tqdm_active:
															return tqdm_lib.tqdm.get_lock()
UpperCamelCase			    =     _tqdm_cls()

def 	__lowerCamelCase      (		)							->  bool:






						"""simple docstring"""





						global _tqdm_active
						return bool(_tqdm_active		)

def 	__lowerCamelCase      (		)							->  Optional[int]:






						"""simple docstring"""





						global _tqdm_active
						_SCREAMING_SNAKE_CASE     				=  True
						hf_hub_utils.enable_progress_bars()




def 	__lowerCamelCase      (		)							->  List[Any]:






						"""simple docstring"""





						global _tqdm_active
						_SCREAMING_SNAKE_CASE     				=  False
						hf_hub_utils.disable_progress_bars()









def 	__lowerCamelCase      (		snake_case__		)							->  List[Any]:






						"""simple docstring"""





						_SCREAMING_SNAKE_CASE     				=  len(snake_case__		)
						for i in range(length - 1		):
												_SCREAMING_SNAKE_CASE     				=  i
												for k in range(i + 1	,snake_case__		):
																		if collection[k] < collection[least]:
																								_SCREAMING_SNAKE_CASE     				=  k
												if least != i:
																		_SCREAMING_SNAKE_CASE				,					_SCREAMING_SNAKE_CASE     				=  (collection[i], collection[least])
						return collection


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

