





"""simple docstring"""




import argparse
import hashlib  # hashlib is only used inside the Test class
import struct


class 			__UpperCamelCase							:






							def __init__(  self ,   lowerCAmelCase__ )      ->					Optional[Any]:
								a :						Dict      =							data
								a :						Tuple      =							[0x67_452_301, 0xef_cda_b89, 0x98_bad_cfe, 0x10_325_476, 0xc3_d2e_1f0]






							@staticmethod
							def        __a  (  lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					Union[str, Any]:
								return ((n << b) | (n >> (32 - b))) & 0xff_fff_fff






							def        __a  (  self )      ->					Union[str, Any]:
								a :						Tuple      =							b"\x80" + b"\x00" * (63 - (len(self.data ) + 8) % 64)
								a :						Optional[Any]      =							self.data + padding + struct.pack(">Q" ,   8 * len(self.data ) )
								return padded_data






							def        __a  (  self )      ->					Optional[Any]:
								return [
								    self.padded_data[i : i + 64] for i in range(0 ,   len(self.padded_data ) ,   64 )
								]






							def        __a  (  self ,   lowerCAmelCase__ )      ->					int:
								a :						Optional[Any]      =							list(struct.unpack(">16L" ,   lowerCAmelCase__ ) ) + [0] * 64
								for i in range(16 ,   80 ):
									a :						Union[str, Any]      =							self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16]) ,   1 )
								return w






							def        __a  (  self )      ->					int:
								a :						Optional[Any]      =							self.padding()
								a :						Tuple      =							self.split_blocks()
								for block in self.blocks:
									a :						int      =							self.expand_block(lowerCAmelCase__ )
									a,			a,			a,			a,			a :						List[str]      =							self.h
									for i in range(0 ,   80 ):
										if 0 <= i < 20:
											a :						int      =							(b & c) | ((~b) & d)
											a :						Tuple      =							0x5a_827_999
										elif 20 <= i < 40:
											a :						Optional[Any]      =							b ^ c ^ d
											a :						Optional[int]      =							0x6e_d9e_ba1
										elif 40 <= i < 60:
											a :						str      =							(b & c) | (b & d) | (c & d)
											a :						int      =							0x8f_1bb_cdc
										elif 60 <= i < 80:
											a :						Union[str, Any]      =							b ^ c ^ d
											a :						Optional[int]      =							0xca_62c_1d6
										a,			a,			a,			a,			a :						Optional[int]      =							(
										    self.rotate(lowerCAmelCase__ ,   5 ) + f + e + k + expanded_block[i] & 0xff_fff_fff,
										    a,
										    self.rotate(lowerCAmelCase__ ,   30 ),
										    c,
										    d,
										)
									a :						Tuple      =							(
									    self.h[0] + a & 0xff_fff_fff,
									    self.h[1] + b & 0xff_fff_fff,
									    self.h[2] + c & 0xff_fff_fff,
									    self.h[3] + d & 0xff_fff_fff,
									    self.h[4] + e & 0xff_fff_fff,
									)
								return ("{:08x}" * 5).format(*self.h )






def  _SCREAMING_SNAKE_CASE						(      )					->Union[str, Any]:






	'''simple docstring'''






	a :						Dict      =							B"Test String"
	assert SHAaHash(_lowercase   ).final_hash() == hashlib.shaa(_lowercase   ).hexdigest()  # noqa: S324






def  _SCREAMING_SNAKE_CASE						(      )					->List[Any]:






	'''simple docstring'''






	a :						Dict      =							argparse.ArgumentParser(description="Process some strings or files"   )
	parser.add_argument(
	    "--string"       ,			dest="input_string"       ,			default="Hello World!! Welcome to Cryptography"       ,			help="Hash the string"       ,			)
	parser.add_argument("--file"       ,			dest="input_file"       ,			help="Hash contents of a file"   )
	a :						Union[str, Any]      =							parser.parse_args()
	a :						Optional[int]      =							args.input_string
	# In any case hash input should be a bytestring
	if args.input_file:
		with open(args.input_file       ,			"rb"   ) as f:
			a :						Optional[Any]      =							f.read()
	else:
		a :						List[str]      =							bytes(_lowercase       ,			"utf-8"   )
	print(SHAaHash(_lowercase   ).final_hash()   )


if __name__ == "__main__":
		main()
		import doctest

		doctest.testmod()









"""simple docstring"""




import math






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int = 0       ,			_lowercase		:       int = 0   )					->list:






	'''simple docstring'''






	a :						Optional[Any]      =							end or len(_lowercase   )
	for i in range(_lowercase       ,			_lowercase   ):
		a :						List[str]      =							i
		a :						Any      =							array[i]
		while temp_index != start and temp_index_value < array[temp_index - 1]:
			a :						Optional[Any]      =							array[temp_index - 1]
			temp_index -= 1
		a :						Any      =							temp_index_value
	return array






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->None:  # Max Heap






	'''simple docstring'''






	a :						Tuple      =							index
	a :						List[Any]      =							2 * index + 1  # Left Node
	a :						Dict      =							2 * index + 2  # Right Node

	if left_index < heap_size and array[largest] < array[left_index]:
		a :						Dict      =							left_index

	if right_index < heap_size and array[largest] < array[right_index]:
		a :						int      =							right_index

	if largest != index:
		a,			a :						List[Any]      =							array[largest], array[index]
		heapify(_lowercase       ,			_lowercase       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list   )					->list:






	'''simple docstring'''






	a :						int      =							len(_lowercase   )

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

	for i in range(n - 1       ,			0       ,			-1   ):
		a,			a :						str      =							array[0], array[i]
		heapify(_lowercase       ,			0       ,			_lowercase   )

	return array






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->int:






	'''simple docstring'''






	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						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->int:






	'''simple docstring'''






	a :						List[Any]      =							low
	a :						int      =							high
	while True:
		while array[i] < pivot:
			i += 1
		j -= 1
		while pivot < array[j]:
			j -= 1
		if i >= j:
			return i
		a,			a :						Union[str, Any]      =							array[j], array[i]
		i += 1






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list   )					->list:






	'''simple docstring'''






	if len(_lowercase   ) == 0:
		return array
	a :						Tuple      =							2 * math.ceil(math.loga(len(_lowercase   )   )   )
	a :						List[str]      =							16
	return intro_sort(_lowercase       ,			0       ,			len(_lowercase   )       ,			_lowercase       ,			_lowercase   )






def  _SCREAMING_SNAKE_CASE						(      _lowercase		:       list       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int       ,			_lowercase		:       int   )					->list:






	'''simple docstring'''






	while end - start > size_threshold:
		if max_depth == 0:
			return heap_sort(_lowercase   )
		max_depth -= 1
		a :						List[str]      =							median_of_a(_lowercase       ,			_lowercase       ,			start + ((end - start) // 2) + 1       ,			end - 1   )
		a :						Tuple      =							partition(_lowercase       ,			_lowercase       ,			_lowercase       ,			_lowercase   )
		intro_sort(_lowercase       ,			_lowercase       ,			_lowercase       ,			_lowercase       ,			_lowercase   )
		a :						Union[str, Any]      =							p
	return insertion_sort(_lowercase       ,			_lowercase       ,			_lowercase   )


if __name__ == "__main__":
		import doctest

		doctest.testmod()

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


