






from collections import deque


def __A    (      __lowerCAmelCase	)->  str:





						"""simple docstring"""



						_UpperCAmelCase									=			len(__lowerCAmelCase	)
						_UpperCAmelCase									=			deque()
						_UpperCAmelCase									=			[False for _ in range(__lowerCAmelCase	)]
						_UpperCAmelCase									=			[-1 for _ in range(__lowerCAmelCase	)]
						_UpperCAmelCase									=			index_of[:]

						def strong_connect(__lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	):
												_UpperCAmelCase									=			index  # the number when this node is seen
												_UpperCAmelCase									=			index  # lowest rank node reachable from here
												index += 1
												stack.append(__lowerCAmelCase	)
												_UpperCAmelCase									=			True

												for w in g[v]:
																		if index_of[w] == -1:
																								_UpperCAmelCase									=			strong_connect(__lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	)
																								_UpperCAmelCase									=			(
																								    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
																								)
																		elif on_stack[w]:
																								_UpperCAmelCase									=			(
																								    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
																								)

												if lowlink_of[v] == index_of[v]:
																		_UpperCAmelCase									=			[]
																		_UpperCAmelCase									=			stack.pop()
																		_UpperCAmelCase									=			False
																		component.append(__lowerCAmelCase	)
																		while w != v:
																								_UpperCAmelCase									=			stack.pop()
																								_UpperCAmelCase									=			False
																								component.append(__lowerCAmelCase	)
																		components.append(__lowerCAmelCase	)
												return index

						_UpperCAmelCase									=			[]
						for v in range(__lowerCAmelCase	):
												if index_of[v] == -1:
																		strong_connect(__lowerCAmelCase ,		0 ,		__lowerCAmelCase	)

						return components


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  List[str]:





						"""simple docstring"""



						_UpperCAmelCase									=			[[] for _ in range(__lowerCAmelCase	)]
						for u, v in edges:
												g[u].append(__lowerCAmelCase	)
						return g


if __name__ == "__main__":
		# Test
		_a      	=  7
		_a      	=  [0, 0, 1, 2, 3, 3, 4, 4, 6]
		_a      	=  [1, 3, 2, 0, 1, 4, 5, 6, 5]
		_a      	=  [(u, v) for u, v in zip(source, target)]
		_a      	=  create_graph(n_vertices, edges)

		assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)


import math





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__ = 0	, lowerCamelCase__ = 0    ):
				lowerCamelCase_						=			end or len(lowerCamelCase__    )
				for i in range(lowerCamelCase__	, lowerCamelCase__    ):
								lowerCamelCase_						=			i
								lowerCamelCase_						=			array[i]
								while temp_index != start and temp_index_value < array[temp_index - 1]:
												lowerCamelCase_						=			array[temp_index - 1]
												temp_index -= 1
								lowerCamelCase_						=			temp_index_value
				return array





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):  # Max Heap
				lowerCamelCase_						=			index
				lowerCamelCase_						=			2 * index + 1  # Left Node
				lowerCamelCase_						=			2 * index + 2  # Right Node

				if left_index < heap_size and array[largest] < array[left_index]:
								lowerCamelCase_						=			left_index

				if right_index < heap_size and array[largest] < array[right_index]:
								lowerCamelCase_						=			right_index

				if largest != index:
								lowerCamelCase_	,    lowerCamelCase_						=			array[largest], array[index]
								heapify(lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    )





def 			lowerCamelCase_ (				lowerCamelCase__    ):
				lowerCamelCase_						=			len(lowerCamelCase__    )

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

				for i in range(n - 1	, 0	, -1    ):
								lowerCamelCase_	,    lowerCamelCase_						=			array[0], array[i]
								heapify(lowerCamelCase__	, 0	, lowerCamelCase__    )

				return array





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):
				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 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):
				lowerCamelCase_						=			low
				lowerCamelCase_						=			high
				while True:
								while array[i] < pivot:
												i += 1
								j -= 1
								while pivot < array[j]:
												j -= 1
								if i >= j:
												return i
								lowerCamelCase_	,    lowerCamelCase_						=			array[j], array[i]
								i += 1





def 			lowerCamelCase_ (				lowerCamelCase__    ):
				if len(lowerCamelCase__    ) == 0:
								return array
				lowerCamelCase_						=			2 * math.ceil(math.loga(len(lowerCamelCase__    )    )    )
				lowerCamelCase_						=			1_6
				return intro_sort(lowerCamelCase__	, 0	, len(lowerCamelCase__    )	, lowerCamelCase__	, lowerCamelCase__    )





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):
				while end - start > size_threshold:
								if max_depth == 0:
												return heap_sort(lowerCamelCase__    )
								max_depth -= 1
								lowerCamelCase_						=			median_of_a(lowerCamelCase__	, lowerCamelCase__	, start + ((end - start) // 2) + 1	, end - 1    )
								lowerCamelCase_						=			partition(lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    )
								intro_sort(lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    )
								lowerCamelCase_						=			p
				return insertion_sort(lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    )


if __name__ == "__main__":
			import doctest

			doctest.testmod()

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


