





"""simple docstring"""




from __future__ import annotations

from random import random


class 			__UpperCamelCase							:






							def __init__(  self ,   lowerCAmelCase__ = None )      ->					str:
								a :						List[Any]      =							value
								a :						int      =							random()
								a :						Node | None      =							None
								a :						Node | None      =							None






							def __repr__(  self )      ->					str:
								from pprint import pformat

								if self.left is None and self.right is None:
									return f"""'{self.value}: {self.prior:.5}'"""
								else:
									return pformat(
									    {f"""{self.value}: {self.prior:.5}""": (self.left, self.right)} ,   indent=1 )






							def __str__(  self )      ->					str:
								a :						List[str]      =							str(self.value ) + " "
								a :						Any      =							str(self.left or "" )
								a :						Optional[Any]      =							str(self.right or "" )
								return value + left + right






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Node | None       ,			_lowercase		:       int   )					->tuple[Node | None, Node | None]:






	'''simple docstring'''






	if root is None:  # None tree is split into 2 Nones
		return None, None
	elif root.value is None:
		return None, None
	else:
		if value < root.value:
			a,			a :						Dict      =							split(root.left       ,			_lowercase   )
			return left, root
		else:
			a,			a :						Any      =							split(root.right       ,			_lowercase   )
			return root, right






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Node | None       ,			_lowercase		:       Node | None   )					->Node | None:






	'''simple docstring'''






	if (not left) or (not right):  # If one node is None, return the other
		return left or right
	elif left.prior < right.prior:
		a :						Tuple      =							merge(left.right       ,			_lowercase   )
		return left
	else:
		a :						Tuple      =							merge(_lowercase       ,			right.left   )
		return right






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Node | None       ,			_lowercase		:       int   )					->Node | None:






	'''simple docstring'''






	a :						Tuple      =							Node(_lowercase   )
	a,			a :						List[str]      =							split(_lowercase       ,			_lowercase   )
	return merge(merge(_lowercase       ,			_lowercase   )       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Node | None       ,			_lowercase		:       int   )					->Node | None:






	'''simple docstring'''






	a,			a :						List[str]      =							split(_lowercase       ,			value - 1   )
	a,			a :						Tuple      =							split(_lowercase       ,			_lowercase   )
	return merge(_lowercase       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Node | None   )					->None:






	'''simple docstring'''






	if not root:  # None
		return
	else:
		inorder(root.left   )
		print(root.value       ,			end=","   )
		inorder(root.right   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       Node | None       ,			_lowercase		:       str   )					->Node | None:






	'''simple docstring'''






	for arg in args.split():
		if arg[0] == "+":
			a :						Union[str, Any]      =							insert(_lowercase       ,			int(arg[1:]   )   )

		elif arg[0] == "-":
			a :						List[Any]      =							erase(_lowercase       ,			int(arg[1:]   )   )

		else:
			print("Unknown command"   )

	return root






def  _SCREAMING_SNAKE_CASE						(      )					->None:






	'''simple docstring'''






	a :						Optional[Any]      =							None
	print(
	    "enter numbers to create a tree, + value to add value into treap, "
	    "- value to erase all nodes with value. 'q' to quit. "   )

	a :						Union[str, Any]      =							input()
	while args != "q":
		a :						Optional[int]      =							interact_treap(_lowercase       ,			_lowercase   )
		print(_lowercase   )
		a :						Any      =							input()

	print("good by!"   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		main()









"""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))


