





'''simple docstring'''






def 				_lowerCamelCase(	UpperCamelCase__     :			Optional[Any]     ,							UpperCamelCase__     :			int     ,							UpperCamelCase__     :			Optional[int]     ,							UpperCamelCase__     :			Tuple		)		->	Optional[int]:
    if start == end:
        return start if lst[start] > item else start + 1
    if start > end:
        return start

    A							:							List[str]				=    (start + end) // 2
    if lst[mid] < item:
        return binary_search(UpperCamelCase__     ,							UpperCamelCase__     ,							mid + 1     ,							UpperCamelCase__		)
    elif lst[mid] > item:
        return binary_search(UpperCamelCase__     ,							UpperCamelCase__     ,							UpperCamelCase__     ,							mid - 1		)
    else:
        return mid
def 				_lowerCamelCase(	UpperCamelCase__     :			int		)		->	Tuple:
    A							:							Union[str, Any]				=    len(UpperCamelCase__		)

    for index in range(1     ,							UpperCamelCase__		):
        A							:							int				=    lst[index]
        A							:							Union[str, Any]				=    binary_search(UpperCamelCase__     ,							UpperCamelCase__     ,							0     ,							index - 1		)
        A							:							Dict				=    lst[:pos] + [value] + lst[pos:index] + lst[index + 1 :]

    return lst
def 				_lowerCamelCase(	UpperCamelCase__     :			int     ,							UpperCamelCase__     :			Tuple		)		->	str:
    if not left:
        return right

    if not right:
        return left

    if left[0] < right[0]:
        return [left[0], *merge(left[1:]     ,							UpperCamelCase__		)]

    return [right[0], *merge(UpperCamelCase__     ,							right[1:]		)]
def 				_lowerCamelCase(	UpperCamelCase__     :			Dict		)		->	Dict:
    A							:							Dict				=    len(UpperCamelCase__		)
    A							:							Optional[Any]				=    [], []
    A							:							str				=    [lst[0]]
    A							:							List[Any]				=    []
    A							:							Tuple				=    1
    while i < length:
        if lst[i] < lst[i - 1]:
            runs.append(UpperCamelCase__		)
            A							:							Union[str, Any]				=    [lst[i]]
        else:
            new_run.append(lst[i]		)
        i += 1
    runs.append(UpperCamelCase__		)

    for run in runs:
        sorted_runs.append(insertion_sort(UpperCamelCase__		)		)
    for run in sorted_runs:
        A							:							str				=    merge(UpperCamelCase__     ,							UpperCamelCase__		)

    return sorted_array
def 				_lowerCamelCase(	)		->	Dict:
    A							:							Optional[Any]				=    [5, 9, 10, 3, -4, 5, 178, 92, 46, -18, 0, 7]
    A							:							List[str]				=    tim_sort(UpperCamelCase__		)
    print(UpperCamelCase__		)


if __name__ == "__main__":
     main()


'''simple docstring'''







def 				_snake_case (		lowercase						)       ->       Tuple:
				__a       :     Union[str, Any]								=	[7_0_1, 3_0_1, 1_3_2, 5_7, 2_3, 1_0, 4, 1]
				for gap in gaps:
								for i in range(lowercase			,    len(lowercase						)						):
												__a       :     Tuple								=	collection[i]
												__a       :     Optional[int]								=	i
												while j >= gap and collection[j - gap] > insert_value:
																__a       :     Tuple								=	collection[j - gap]
																j -= gap
												if j != i:
																__a       :     Dict								=	insert_value
				return collection


if __name__ == "__main__":
					from doctest import testmod

					testmod()
					__SCREAMING_SNAKE_CASE		:  Any        =      input('Enter numbers separated by a comma:\n').strip()
					__SCREAMING_SNAKE_CASE		:  Optional[int]        =      [int(item) for item in user_input.split(',')]
					print(shell_sort(unsorted))