




"""simple docstring"""




import gc
import threading
import time

import psutil
import torch

class   UpperCAmelCase_    :
		def __init__(						self       )						->       str:
					__lowercase			:  List[Any]								=       psutil.Process()
					__lowercase			:  Any								=       False
		def 	_lowerCamelCase							(						self       )						->       Union[str, Any]:
					__lowercase			:  Optional[Any]								=       -1

					while True:
								__lowercase			:  List[str]								=       max(self.process.memory_info().rss				,						self.cpu_memory_peak       )

								# can't sleep or will not catch the peak right (this comment is here on purpose)
								if not self.peak_monitoring:
											break
		def 	_lowerCamelCase							(						self       )						->       Optional[Any]:
					__lowercase			:  List[Any]								=       True
					__lowercase			:  List[Any]								=       threading.Thread(target=self.peak_monitor       )
					__lowercase			:  Optional[int]								=       True
					self.thread.start()
		def 	_lowerCamelCase							(						self       )						->       Optional[Any]:
					__lowercase			:  Union[str, Any]								=       False
					self.thread.join()
					return self.cpu_memory_peak


a_        =       PeakCPUMemory()







def      __UpperCAmelCase     ( ):
			# Time
			__lowercase			:  Union[str, Any]								=       {'''time''': time.time()}

			gc.collect()
			torch.cuda.empty_cache()

			# CPU mem
			__lowercase			:  List[Any]								=       psutil.Process().memory_info().rss
			cpu_peak_tracker.start()

			# GPU mem
			for i in range(torch.cuda.device_count()	):
						__lowercase			:  List[str]								=       torch.cuda.memory_allocated(__UpperCamelCase	)
			torch.cuda.reset_peak_memory_stats()

			return measures







def      __UpperCAmelCase     ( __UpperCamelCase	):
			# Time
			__lowercase			:  List[Any]								=       {'''time''': time.time() - start_measures['''time''']}

			gc.collect()
			torch.cuda.empty_cache()

			# CPU mem
			__lowercase			:  Union[str, Any]								=       (psutil.Process().memory_info().rss - start_measures['''cpu''']) / 2**20
			__lowercase			:  Dict								=       (cpu_peak_tracker.stop() - start_measures['''cpu''']) / 2**20

			# GPU mem
			for i in range(torch.cuda.device_count()	):
						__lowercase			:  str								=       (torch.cuda.memory_allocated(__UpperCamelCase	) - start_measures[str(__UpperCamelCase	)]) / 2**20
						__lowercase			:  Optional[int]								=       (torch.cuda.max_memory_allocated(__UpperCamelCase	) - start_measures[str(__UpperCamelCase	)]) / 2**20

			return measures







def      __UpperCAmelCase     ( __UpperCamelCase	,				__UpperCamelCase	):
			print(f"""{description}:"""	)
			print(f"""- Time: {measures["time"]:.2f}s"""	)
			for i in range(torch.cuda.device_count()	):
						print(f"""- GPU {i} allocated: {measures[str(__UpperCamelCase	)]:.2f}MiB"""	)
						__lowercase			:  Dict								=       measures[f"""{i}-peak"""]
						print(f"""- GPU {i} peak: {peak:.2f}MiB"""	)
			print(f"""- CPU RAM allocated: {measures["cpu"]:.2f}MiB"""	)
			print(f"""- CPU RAM peak: {measures["cpu-peak"]:.2f}MiB"""	)










"""simple docstring"""




import math






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int = 0       ,			_lowercase		:       int = 0   )					->list:






	'''simple docstring'''






	a :						Optional[Any]      =							end or len(_lowercase   )
	for i in range(_lowercase       ,			_lowercase   ):
		a :						List[str]      =							i
		a :						Any      =							array[i]
		while temp_index != start and temp_index_value < array[temp_index - 1]:
			a :						Optional[Any]      =							array[temp_index - 1]
			temp_index -= 1
		a :						Any      =							temp_index_value
	return array






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->None:  # Max Heap






	'''simple docstring'''






	a :						Tuple      =							index
	a :						List[Any]      =							2 * index + 1  # Left Node
	a :						Dict      =							2 * index + 2  # Right Node

	if left_index < heap_size and array[largest] < array[left_index]:
		a :						Dict      =							left_index

	if right_index < heap_size and array[largest] < array[right_index]:
		a :						int      =							right_index

	if largest != index:
		a,			a :						List[Any]      =							array[largest], array[index]
		heapify(_lowercase       ,			_lowercase       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list   )					->list:






	'''simple docstring'''






	a :						int      =							len(_lowercase   )

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

	for i in range(n - 1       ,			0       ,			-1   ):
		a,			a :						str      =							array[0], array[i]
		heapify(_lowercase       ,			0       ,			_lowercase   )

	return array






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->int:






	'''simple docstring'''






	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						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->int:






	'''simple docstring'''






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






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list   )					->list:






	'''simple docstring'''






	if len(_lowercase   ) == 0:
		return array
	a :						Tuple      =							2 * math.ceil(math.loga(len(_lowercase   )   )   )
	a :						List[str]      =							16
	return intro_sort(_lowercase       ,			0       ,			len(_lowercase   )       ,			_lowercase       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->list:






	'''simple docstring'''






	while end - start > size_threshold:
		if max_depth == 0:
			return heap_sort(_lowercase   )
		max_depth -= 1
		a :						List[str]      =							median_of_a(_lowercase       ,			_lowercase       ,			start + ((end - start) // 2) + 1       ,			end - 1   )
		a :						Tuple      =							partition(_lowercase       ,			_lowercase       ,			_lowercase       ,			_lowercase   )
		intro_sort(_lowercase       ,			_lowercase       ,			_lowercase       ,			_lowercase       ,			_lowercase   )
		a :						Union[str, Any]      =							p
	return insertion_sort(_lowercase       ,			_lowercase       ,			_lowercase   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()

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


