code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase      ,			lowercase      ,			lowercase			)      ->      Optional[int]:
  			__lowerCAmelCase      		=       index
  			__lowerCAmelCase      		=       2 * index + 1
  			__lowerCAmelCase      		=       2 * index + 2
  			if left_index < heap_size and unsorted[left_index] > unsorted[largest]:
  						__lowerCAmelCase      		=       left_index
  
  			if right_index < heap_size and unsorted[right_index] > unsorted[largest]:
  						__lowerCAmelCase      		=       right_index
  
  			if largest != index:
  						__lowerCAmelCase      		=       unsorted[index], unsorted[largest]
  						heapify(snake_case__      ,			snake_case__      ,			snake_case__			)
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      str:
  			__lowerCAmelCase      		=       len(snake_case__			)
  			for i in range(n // 2 - 1      ,			-1      ,			-1			):
  						heapify(snake_case__      ,			snake_case__      ,			snake_case__			)
  			for i in range(n - 1      ,			0      ,			-1			):
  						__lowerCAmelCase      		=       unsorted[i], unsorted[0]
  						heapify(snake_case__      ,			0      ,			snake_case__			)
  			return unsorted
  
  
  if __name__ == "__main__":
  	_a      :				List[str]											=					input("""Enter numbers separated by a comma:\n""").strip()
  	_a      :				List[str]											=					[int(item) for item in user_input.split(""",""")]
  	print(heap_sort(unsorted))
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  from __future__ import annotations
  
  from collections.abc import Iterable, Iterator
  from typing import Any, Generic, TypeVar
  
  _a      :				Dict											=					TypeVar("""T""", bound=bool)
  
  
  
  
  
  class 					_UpperCAmelCase							(		Generic[T]     ):
  		def __init__(						self,__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       value
  					__lowerCAmelCase      		=       None
  					__lowerCAmelCase      		=       None
  		@property
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					return self._value
  
  
  
  
  
  
  
  		@staticmethod
  		def 						lowerCamelCase__    (						__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					if not roota:
  								return roota
  
  					if not roota:
  								return roota
  
  					if roota.value > roota.value:
  								__lowerCAmelCase		, __lowerCAmelCase      		=       roota, roota
  
  					__lowerCAmelCase      		=       roota
  					__lowerCAmelCase      		=       roota.right
  					__lowerCAmelCase      		=       roota.left
  					__lowerCAmelCase      		=       SkewNode.merge(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )
  
  					return result
  
  
  
  
  
  class 					_UpperCAmelCase							(		Generic[T]     ):
  		def __init__(						self,__SCREAMING_SNAKE_CASE = ()    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       None
  					if data:
  								for item in data:
  											self.insert(__SCREAMING_SNAKE_CASE    )
  		def __bool__(						self    ):
  
  
  
  					'''simple docstring'''
  
  					return self._root is not None
  		def __iter__(						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       []
  					while self:
  								result.append(self.pop()    )
  
  					# Pushing items back to the heap not to clear it.
  					for item in result:
  								self.insert(__SCREAMING_SNAKE_CASE    )
  
  					return iter(__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       SkewNode.merge(self._root,SkewNode(__SCREAMING_SNAKE_CASE    )    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.top()
  					__lowerCAmelCase      		=       (
  					    SkewNode.merge(self._root.left,self._root.right    ) if self._root else None
  					)
  
  					return result
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					if not self._root:
  								raise IndexError("""Can't get top element for the empty heap."""    )
  					return self._root.value
  
  
  
  
  
  
  
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       None
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  