





import math







def  _SCREAMING_SNAKE_CASE				(   a					,						a = 0					,						a = 0  )      ->      list:
					__A	:						List[str]       =				end or len(a  )
					for i in range(a					,						a  ):
										__A	:						List[str]       =				i
										__A	:						Optional[int]       =				array[i]
										while temp_index != start and temp_index_value < array[temp_index - 1]:
															__A	:						List[str]       =				array[temp_index - 1]
															temp_index -= 1
										__A	:						Optional[Any]       =				temp_index_value
					return array







def  _SCREAMING_SNAKE_CASE				(   a					,						a					,						a  )      ->      None:  # Max Heap
					__A	:						int       =				index
					__A	:						Tuple       =				2 * index + 1  # Left Node
					__A	:						List[str]       =				2 * index + 2  # Right Node

					if left_index < heap_size and array[largest] < array[left_index]:
										__A	:						List[str]       =				left_index

					if right_index < heap_size and array[largest] < array[right_index]:
										__A	:						Dict       =				right_index

					if largest != index:
										__A    ,				__A	:						Tuple       =				array[largest], array[index]
										heapify(a					,						a					,						a  )







def  _SCREAMING_SNAKE_CASE				(   a  )      ->      list:
					__A	:						Union[str, Any]       =				len(a  )

					for i in range(n // 2					,						-1					,						-1  ):
										heapify(a					,						a					,						a  )

					for i in range(n - 1					,						0					,						-1  ):
										__A    ,				__A	:						Optional[Any]       =				array[0], array[i]
										heapify(a					,						0					,						a  )

					return array







def  _SCREAMING_SNAKE_CASE				(   a					,						a					,						a					,						a  )      ->      int:
					if (array[first_index] > array[middle_index]) != (
					    array[first_index] > array[last_index]
					):
										return array[first_index]
					elif (array[middle_index] > array[first_index]) != (
					    array[middle_index] > array[last_index]
					):
										return array[middle_index]
					else:
										return array[last_index]







def  _SCREAMING_SNAKE_CASE				(   a					,						a					,						a					,						a  )      ->      int:
					__A	:						Any       =				low
					__A	:						Any       =				high
					while True:
										while array[i] < pivot:
															i += 1
										j -= 1
										while pivot < array[j]:
															j -= 1
										if i >= j:
															return i
										__A    ,				__A	:						List[str]       =				array[j], array[i]
										i += 1







def  _SCREAMING_SNAKE_CASE				(   a  )      ->      list:
					if len(a  ) == 0:
										return array
					__A	:						Any       =				2 * math.ceil(math.loga(len(a  )  )  )
					__A	:						Union[str, Any]       =				16
					return intro_sort(a					,						0					,						len(a  )					,						a					,						a  )







def  _SCREAMING_SNAKE_CASE				(   a					,						a					,						a					,						a					,						a  )      ->      list:
					while end - start > size_threshold:
										if max_depth == 0:
															return heap_sort(a  )
										max_depth -= 1
										__A	:						Tuple       =				median_of_a(a					,						a					,						start + ((end - start) // 2) + 1					,						end - 1  )
										__A	:						Dict       =				partition(a					,						a					,						a					,						a  )
										intro_sort(a					,						a					,						a					,						a					,						a  )
										__A	:						Optional[int]       =				p
					return insertion_sort(a					,						a					,						a  )


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				UpperCAmelCase						:   List[Any]			  =     input('''Enter numbers separated by a comma : ''').strip()
				UpperCAmelCase						:   Optional[int]			  =     [float(item) for item in user_input.split(''',''')]
				print(sort(unsorted))











def  _SCREAMING_SNAKE_CASE				(   a					,						a = 0  )      ->      list:
					__A	:						int       =				length or len(a  )
					__A	:						str       =				False
					for i in range(length - 1  ):
										if list_data[i] > list_data[i + 1]:
															__A    ,				__A	:						Optional[int]       =				list_data[i + 1], list_data[i]
															__A	:						Union[str, Any]       =				True

					return list_data if not swapped else bubble_sort(a					,						length - 1  )


if __name__ == "__main__":
				import doctest

				doctest.testmod()




