"""simple docstring"""



import logging
import os
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


SCREAMING_SNAKE_CASE__:List[Any]			=	{
    """debug""": logging.DEBUG,
    """info""": logging.INFO,
    """warning""": logging.WARNING,
    """error""": logging.ERROR,
    """critical""": logging.CRITICAL,
}

SCREAMING_SNAKE_CASE__:int			=	logging.WARNING



def 					_lowerCamelCase(					):
       __a     				=  os.getenv("DATASETS_VERBOSITY" ,  a							)
       if env_level_str:
              if env_level_str in log_levels:
                     return log_levels[env_level_str]
              else:
                     logging.getLogger().warning(
                         F"Unknown option DATASETS_VERBOSITY={env_level_str}, "
                         F"has to be one of: { ', '.join(log_levels.keys()							) }"							)
       return _default_log_level



def 					_lowerCamelCase(					):
       return __name__.split("."							)[0]



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



def 					_lowerCamelCase(					):
       # Apply our default configuration to the library root logger.
       __a     				=  _get_library_root_logger()
       library_root_logger.setLevel(_get_default_logging_level()							)



def 					_lowerCamelCase(					):
       __a     				=  _get_library_root_logger()
       library_root_logger.setLevel(logging.NOTSET							)



def 					_lowerCamelCase(					a = None							):
       if name is None:
              __a     				=  _get_library_name()
       return logging.getLogger(a							)



def 					_lowerCamelCase(					):
       return _get_library_root_logger().getEffectiveLevel()



def 					_lowerCamelCase(					a							):
       _get_library_root_logger().setLevel(a							)



def 					_lowerCamelCase(					):
       return set_verbosity(a							)



def 					_lowerCamelCase(					):
       return set_verbosity(a							)



def 					_lowerCamelCase(					):
       return set_verbosity(a							)



def 					_lowerCamelCase(					):
       return set_verbosity(a							)



def 					_lowerCamelCase(					):
       __a     				=  False



def 					_lowerCamelCase(					):
       __a     				=  True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()






class 				snake_case__     :


 def __init__(				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):  # pylint: disable=unused-argument
        __a     				=  args[0] if args else None


 def __iter__(				self		):
        return iter(self._iterator		)


 def __getattr__(				self  ,						lowerCamelCase		):

        def empty_fn(*lowerCamelCase  ,						**lowerCamelCase		):  # pylint: disable=unused-argument
               return

        return empty_fn


 def __enter__(				self		):
        return self






 def __exit__(				self  ,						lowerCamelCase  ,						lowerCamelCase  ,						lowerCamelCase		):
        return
SCREAMING_SNAKE_CASE__:List[str]			=	True






class 				snake_case__     :


 def __call__(				self  ,						*lowerCamelCase  ,						lowerCamelCase=False  ,						**lowerCamelCase		):
        if _tqdm_active and not disable:
               return tqdm_lib.tqdm(*lowerCamelCase  ,						**lowerCamelCase		)
        else:
               return EmptyTqdm(*lowerCamelCase  ,						**lowerCamelCase		)


 def 		a__ (				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        __a     				=  None
        if _tqdm_active:
               return tqdm_lib.tqdm.set_lock(*lowerCamelCase  ,						**lowerCamelCase		)






 def 		a__ (				self		):
        if _tqdm_active:
               return tqdm_lib.tqdm.get_lock()
SCREAMING_SNAKE_CASE__:Optional[Any]			=	_tqdm_cls()



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



def 					_lowerCamelCase(					):
       global _tqdm_active
       __a     				=  True




def 					_lowerCamelCase(					):
       global _tqdm_active
       __a     				=  False

"""simple docstring"""



def 					_lowerCamelCase(					a							):
       __a     				=  len(a							)
       for i in range(1 ,  a							):
              __a     				=  collection[i]
              __a     				=  0
              __a     				=  i - 1

              while low <= high:
                     __a     				=  (low + high) // 2
                     if val < collection[mid]:
                            __a     				=  mid - 1
                     else:
                            __a     				=  mid + 1
              for j in range(a ,  a ,  -1							):
                     __a     				=  collection[j - 1]
              __a     				=  val
       return collection


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