from __future__ import annotations

def     lowercase_       (    _lowerCamelCase							: List[str]	,			_lowerCamelCase							: Tuple):
    lowercase__				:     int					      =       0
    lowercase__				:     Tuple					      =       len(_lowerCamelCase) - 1
    while left <= right:
        lowercase__				:     Optional[int]					      =       (left + right) // 2
        if left == right:
            if sorted_list[middle] < item:
                lowercase__				:     Union[str, Any]					      =       middle + 1
            break
        elif sorted_list[middle] < item:
            lowercase__				:     int					      =       middle + 1
        else:
            lowercase__				:     Optional[int]					      =       middle - 1
    sorted_list.insert(_lowerCamelCase	,			_lowerCamelCase)
    return sorted_list

def     lowercase_       (    _lowerCamelCase							: Optional[int]	,			_lowerCamelCase							: Union[str, Any]):
    lowercase__				:     Tuple					      =       []
    while left and right:
        if left[0][0] < right[0][0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0))
    return result + left + right

def     lowercase_       (    _lowerCamelCase							: Tuple):
    lowercase__				:     List[Any]					      =       len(_lowerCamelCase)
    if length <= 1:
        return list_ad
    lowercase__				:     str					      =       length // 2
    return merge(sortlist_ad(list_ad[:middle])	,			sortlist_ad(list_ad[middle:]))

def     lowercase_       (    _lowerCamelCase							: list[int]):

    if len(_lowerCamelCase) <= 1:
        return collection
    lowercase__				:     Any					      =       []
    lowercase__				:     str					      =       False
    for i in range(0	,			len(_lowerCamelCase)	,			2):
        if i == len(_lowerCamelCase) - 1:
            lowercase__				:     Any					      =       True
        else:
            if collection[i] < collection[i + 1]:
                two_paired_list.append([collection[i], collection[i + 1]])
            else:
                two_paired_list.append([collection[i + 1], collection[i]])
    lowercase__				:     Optional[int]					      =       sortlist_ad(_lowerCamelCase)
    lowercase__				:     Optional[int]					      =       [i[0] for i in sorted_list_ad]
    result.append(sorted_list_ad[-1][1])
    if has_last_odd_item:
        lowercase__				:     Optional[Any]					      =       collection[-1]
        lowercase__				:     Union[str, Any]					      =       binary_search_insertion(_lowerCamelCase	,			_lowerCamelCase)
    lowercase__				:     List[str]					      =       False
    for i in range(len(_lowerCamelCase) - 1):
        if result[i] == collection[-1] and has_last_odd_item:
            lowercase__				:     Tuple					      =       True
        lowercase__				:     str					      =       sorted_list_ad[i][1]
        # If last_odd_item is inserted before the item's index,
        # you should forward index one more.
        if is_last_odd_item_inserted_before_this_index:
            lowercase__				:     Any					      =       result[: i + 2] + binary_search_insertion(result[i + 2 :]	,			_lowerCamelCase)
        else:
            lowercase__				:     Optional[int]					      =       result[: i + 1] + binary_search_insertion(result[i + 1 :]	,			_lowerCamelCase)

    return result


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




from typing import Callable

def     lowercase_       (    _lowerCamelCase							: Callable):

    def wrapper(_lowerCamelCase							: str):
        lowercase__				:     Tuple					      =       function_with_docstring.__doc__
        return target_function

    return wrapper



