import unittest
from timeit import timeit



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	Optional[Any]:
		__A							:   Any	  =				first_num if first_num >= second_num else second_num
		__A							:   Union[str, Any]	  =				max_num
		while (common_mult % first_num > 0) or (common_mult % second_num > 0):
				common_mult += max_num
		return common_mult



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	Any:
		return b if a == 0 else greatest_common_divisor(b % a ,     _A    )



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	Optional[Any]:
		return first_num // greatest_common_divisor(_A ,     _A    ) * second_num



def    lowerCamelCase_   (  )							->	Dict:
		__A							:   Union[str, Any]	  =				(
		    "from __main__ import least_common_multiple_slow, least_common_multiple_fast"
		)
		print(
		    "least_common_multiple_slow():" ,     timeit("least_common_multiple_slow(1000, 999)" ,     setup=_A    ) ,     )
		print(
		    "least_common_multiple_fast():" ,     timeit("least_common_multiple_fast(1000, 999)" ,     setup=_A    ) ,     )


class _a       (	unittest.TestCase ):

	'''simple docstring'''



	lowerCamelCase_   :      List[str]       =	(
	    (1_0, 2_0),
	    (1_3, 1_5),
	    (4, 3_1),
	    (1_0, 4_2),
	    (4_3, 3_4),
	    (5, 1_2),
	    (1_2, 2_5),
	    (1_0, 2_5),
	    (6, 9),
	)
	lowerCamelCase_   :      Optional[Any]       =	(2_0, 1_9_5, 1_2_4, 2_1_0, 1_4_6_2, 6_0, 3_0_0, 5_0, 1_8)

	def 					__UpperCAmelCase(       self   ):






			for i, (first_num, second_num) in enumerate(self.test_inputs   ):
					__A							:   Dict	  =				least_common_multiple_slow(lowercase_							,			lowercase_   )
					__A							:   Any	  =				least_common_multiple_fast(lowercase_							,			lowercase_   )
					with self.subTest(i=lowercase_   ):
							self.assertEqual(lowercase_							,			self.expected_results[i]   )
							self.assertEqual(lowercase_							,			self.expected_results[i]   )


if __name__ == "__main__":
					benchmark()
					unittest.main()






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





