from itertools import compress, repeat
from math import ceil, sqrt



def    lowerCamelCase_   (  _lowercase    )							->	list[int]:

		if num <= 2:
				return []
		if num == 3:
				return [2]

		# Odd sieve for numbers in range [3, num - 1]
		__A							:   str	  =				bytearray(B"\x01"    ) * ((num >> 1) - 1)

		for i in range(3 ,     int(sqrt(_lowercase    )    ) + 1 ,     2    ):
				if sieve[(i >> 1) - 1]:
						__A							:   Tuple	  =				i**2
						__A							:   Optional[int]	  =				repeat(
						    0 ,     ceil((num - i_squared) / (i << 1)    )    )

		return [2] + list(compress(range(3 ,     _lowercase ,     2    ) ,     _lowercase    )    )


if __name__ == "__main__":
					import doctest

					doctest.testmod()






def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase    )							->	Tuple:
		__A							:   Union[str, Any]	  =				index
		__A							:   int	  =				2 * index + 1
		__A							:   Dict	  =				2 * index + 2
		if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
				__A							:   Dict	  =				left_index

		if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
				__A							:   int	  =				right_index

		if largest != index:
				__A  ,       __A							:   Dict	  =				unsorted[index], unsorted[largest]
				heapify(_lowercase ,     _lowercase ,     _lowercase    )



def    lowerCamelCase_   (  _lowercase    )							->	Tuple:
		__A							:   Dict	  =				len(_lowercase    )
		for i in range(n // 2 - 1 ,     -1 ,     -1    ):
				heapify(_lowercase ,     _lowercase ,     _lowercase    )
		for i in range(n - 1 ,     0 ,     -1    ):
				__A  ,       __A							:   Dict	  =				unsorted[i], unsorted[0]
				heapify(_lowercase ,     0 ,     _lowercase    )
		return unsorted


if __name__ == "__main__":
					UpperCamelCase      			=     input('Enter numbers separated by a comma:\n').strip()
					UpperCamelCase      			=     [int(item) for item in user_input.split(',')]
					print(heap_sort(unsorted))





