






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







class  _lowercase   :
      def __init__(     self				,			a   ):
       snake_case__  :    List[str]							       =data
       snake_case__  :    Union[str, Any]							       =[0X67_452_301, 0XEF_CDA_B89, 0X98_BAD_CFE, 0X10_325_476, 0XC3_D2E_1F0]
      @staticmethod
      def 						lowercase__					(     a				,			a   ):
       return ((n << b) | (n >> (3_2 - b))) & 0XFF_FFF_FFF
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =B"""\x80""" + B"""\x00""" * (6_3 - (len(self.data   ) + 8) % 6_4)
       snake_case__  :    Any							       =self.data + padding + struct.pack(""">Q"""				,			8 * len(self.data   )   )
       return padded_data
      def 						lowercase__					(     self   ):
       return [
           self.padded_data[i : i + 6_4] for i in range(0				,			len(self.padded_data   )				,			6_4   )
       ]
      def 						lowercase__					(     self				,			a   ):
       snake_case__  :    Dict							       =list(struct.unpack(""">16L"""				,			a   )   ) + [0] * 6_4
       for i in range(1_6				,			8_0   ):
        snake_case__  :    str							       =self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 1_4] ^ w[i - 1_6])				,			1   )
       return w



      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[Any]							       =self.padding()
       snake_case__  :    int							       =self.split_blocks()
       for block in self.blocks:
        snake_case__  :    Union[str, Any]							       =self.expand_block(a   )
        snake_case__       ,   snake_case__       ,   snake_case__       ,   snake_case__       ,   snake_case__  :    Union[str, Any]							       =self.h
        for i in range(0				,			8_0   ):
         if 0 <= i < 2_0:
          snake_case__  :    Optional[int]							       =(b & c) | ((~b) & d)
          snake_case__  :    Tuple							       =0X5A_827_999
         elif 2_0 <= i < 4_0:
          snake_case__  :    Union[str, Any]							       =b ^ c ^ d
          snake_case__  :    str							       =0X6E_D9E_BA1
         elif 4_0 <= i < 6_0:
          snake_case__  :    Dict							       =(b & c) | (b & d) | (c & d)
          snake_case__  :    Dict							       =0X8F_1BB_CDC
         elif 6_0 <= i < 8_0:
          snake_case__  :    Optional[Any]							       =b ^ c ^ d
          snake_case__  :    List[str]							       =0XCA_62C_1D6
         snake_case__       ,   snake_case__       ,   snake_case__       ,   snake_case__       ,   snake_case__  :    Union[str, Any]							       =(
             self.rotate(a				,			5   ) + f + e + k + expanded_block[i] & 0XFF_FFF_FFF,
             a,
             self.rotate(a				,			3_0   ),
             c,
             d,
         )
        snake_case__  :    List[str]							       =(
            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 			A__							(      ):





 '''simple docstring'''







 snake_case__  :    Tuple							       =B"""Test String"""
 assert SHAaHash(_a	).final_hash() == hashlib.shaa(_a	).hexdigest()  # noqa: S324







def 			A__							(      ):





 '''simple docstring'''







 snake_case__  :    str							       =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"""	)
 snake_case__  :    Union[str, Any]							       =parser.parse_args()
 snake_case__  :    List[str]							       =args.input_string
 # In any case hash input should be a bytestring
 if args.input_file:
  with open(args.input_file		,  """rb"""	) as f:
   snake_case__  :    Union[str, Any]							       =f.read()
 else:
  snake_case__  :    Tuple							       =bytes(_a		,  """utf-8"""	)
 print(SHAaHash(_a	).final_hash()	)


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

       doctest.testmod()













import math







def 			A__							(      _a  :					list		,  _a  :					int = 0		,  _a  :					int = 0	):





 '''simple docstring'''







 snake_case__  :    Tuple							       =end or len(_a	)
 for i in range(_a		,  _a	):
  snake_case__  :    int							       =i
  snake_case__  :    int							       =array[i]
  while temp_index != start and temp_index_value < array[temp_index - 1]:
   snake_case__  :    Dict							       =array[temp_index - 1]
   temp_index -= 1
  snake_case__  :    Dict							       =temp_index_value
 return array







def 			A__							(      _a  :					list		,  _a  :					int		,  _a  :					int	):  # Max Heap





 '''simple docstring'''







 snake_case__  :    Tuple							       =index
 snake_case__  :    Dict							       =2 * index + 1  # Left Node
 snake_case__  :    Union[str, Any]							       =2 * index + 2  # Right Node

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

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

 if largest != index:
  snake_case__       ,   snake_case__  :    List[Any]							       =array[largest], array[index]
  heapify(_a		,  _a		,  _a	)







def 			A__							(      _a  :					list	):





 '''simple docstring'''







 snake_case__  :    List[str]							       =len(_a	)

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

 for i in range(n - 1		,  0		,  -1	):
  snake_case__       ,   snake_case__  :    Tuple							       =array[0], array[i]
  heapify(_a		,  0		,  _a	)

 return array







def 			A__							(      _a  :					list		,  _a  :					int		,  _a  :					int		,  _a  :					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 			A__							(      _a  :					list		,  _a  :					int		,  _a  :					int		,  _a  :					int	):





 '''simple docstring'''







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







def 			A__							(      _a  :					list	):





 '''simple docstring'''







 if len(_a	) == 0:
  return array
 snake_case__  :    Optional[int]							       =2 * math.ceil(math.loga(len(_a	)	)	)
 snake_case__  :    Tuple							       =16
 return intro_sort(_a		,  0		,  len(_a	)		,  _a		,  _a	)







def 			A__							(      _a  :					list		,  _a  :					int		,  _a  :					int		,  _a  :					int		,  _a  :					int	):





 '''simple docstring'''







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


if __name__ == "__main__":
       import doctest

       doctest.testmod()

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





