

import math
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int = 0			,a__    :   int = 0       )					->				list:
	__A :			Optional[int]		    =			end or len(a__       )
	for i in range(a__			,a__       ):
		__A :			List[Any]		    =			i
		__A :			Optional[int]		    =			array[i]
		while temp_index != start and temp_index_value < array[temp_index - 1]:
			__A :			Union[str, Any]		    =			array[temp_index - 1]
			temp_index -= 1
		__A :			List[Any]		    =			temp_index_value
	return array
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int       )					->				None:  # Max Heap
	__A :			Optional[int]		    =			index
	__A :			List[Any]		    =			2 * index + 1  # Left Node
	__A :			Optional[Any]		    =			2 * index + 2  # Right Node

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

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

	if largest != index:
		__A    ,				__A :			Optional[Any]		    =			array[largest], array[index]
		heapify(a__			,a__			,a__       )
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list       )					->				list:
	__A :			Tuple		    =			len(a__       )

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

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

	return array
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int			,a__    :   int       )					->				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__    :   list			,a__    :   int			,a__    :   int			,a__    :   int       )					->				int:
	__A :			Tuple		    =			low
	__A :			str		    =			high
	while True:
		while array[i] < pivot:
			i += 1
		j -= 1
		while pivot < array[j]:
			j -= 1
		if i >= j:
			return i
		__A    ,				__A :			int		    =			array[j], array[i]
		i += 1
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list       )					->				list:
	if len(a__       ) == 0:
		return array
	__A :			int		    =			2 * math.ceil(math.loga(len(a__       )       )       )
	__A :			int		    =			16
	return intro_sort(a__			,0			,len(a__       )			,a__			,a__       )
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int			,a__    :   int			,a__    :   int       )					->				list:
	while end - start > size_threshold:
		if max_depth == 0:
			return heap_sort(a__       )
		max_depth -= 1
		__A :			Union[str, Any]		    =			median_of_a(a__			,a__			,start + ((end - start) // 2) + 1			,end - 1       )
		__A :			List[Any]		    =			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_							:					int		 =   input('''Enter numbers separated by a comma : ''').strip()
			UpperCAmelCase_							:					Any		 =   [float(item) for item in user_input.split(''',''')]
			print(sort(unsorted))








UpperCAmelCase_							:					dict[tuple[int, int, int], int]		 =   {}
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int			,a__    :   int			,a__    :   int       )					->				int:

	# if we are absent twice, or late 3 consecutive days,
	# no further prize strings are possible
	if late == 3 or absent == 2:
		return 0

	# if we have no days left, and have not failed any other rules,
	# we have a prize string
	if days == 0:
		return 1

	# No easy solution, so now we need to do the recursive calculation

	# First, check if the combination is already in the cache, and
	# if yes, return the stored value from there since we already
	# know the number of possible prize strings from this point on
	__A :			List[Any]		    =			(days, absent, late)
	if key in cache:
		return cache[key]

	# now we calculate the three possible ways that can unfold from
	# this point on, depending on our attendance today

	# 1) if we are late (but not absent), the "absent" counter stays as
	# it is, but the "late" counter increases by one
	__A :			Dict		    =			_calculate(days - 1			,a__			,late + 1       )

	# 2) if we are absent, the "absent" counter increases by 1, and the
	# "late" counter resets to 0
	__A :			List[str]		    =			_calculate(days - 1			,absent + 1			,0       )

	# 3) if we are on time, this resets the "late" counter and keeps the
	# absent counter
	__A :			int		    =			_calculate(days - 1			,a__			,0       )

	__A :			Optional[int]		    =			state_late + state_absent + state_ontime

	__A :			Tuple		    =			prizestrings
	return prizestrings
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int = 30       )					->				int:
	return _calculate(a__			,absent=0			,late=0       )


if __name__ == "__main__":
			print(solution())





