



from graphs.minimum_spanning_tree_kruskal import kruskal

def   _lowerCAmelCase   (						):
      lowercase__     =  9
      lowercase__     =  [
          [0, 1, 4],
          [0, 7, 8],
          [1, 2, 8],
          [7, 8, 7],
          [7, 6, 1],
          [2, 8, 2],
          [8, 6, 6],
          [2, 3, 7],
          [2, 5, 4],
          [6, 5, 2],
          [3, 5, 14],
          [3, 4, 9],
          [5, 4, 10],
          [1, 7, 11],
      ]

      lowercase__     =  kruskal(A__						,  A__	)

      lowercase__     =  [
          [7, 6, 1],
          [2, 8, 2],
          [6, 5, 2],
          [0, 1, 4],
          [2, 5, 4],
          [2, 3, 7],
          [0, 7, 8],
          [3, 4, 9],
      ]

      assert sorted(A__	) == sorted(A__	)





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



class       UpperCAmelCase__:

   '''simple docstring'''




   def __init__(						self  :			Optional[Any]			,				lowerCAmelCase  :			str)	->				Optional[int]:




         """simple docstring"""

         lowercase__     =  data
         lowercase__     =  [0X6_7_4_5_2_3_0_1, 0XE_F_C_D_A_B_8_9, 0X9_8_B_A_D_C_F_E, 0X1_0_3_2_5_4_7_6, 0XC_3_D_2_E_1_F_0]


   @staticmethod
   def 			UpperCAmelCase		(						lowerCAmelCase  :			Union[str, Any]			,				lowerCAmelCase  :			Optional[int])	->				str:




         """simple docstring"""

         return ((n << b) | (n >> (32 - b))) & 0XF_F_F_F_F_F_F_F


   def 			UpperCAmelCase		(						self  :			Dict)	->				Dict:




         """simple docstring"""

         lowercase__     =  B'\x80' + B'\x00' * (63 - (len(self.data) + 8) % 64)
         lowercase__     =  self.data + padding + struct.pack('>Q'			,				8 * len(self.data))
         return padded_data


   def 			UpperCAmelCase		(						self  :			int)	->				Tuple:




         """simple docstring"""

         return [
             self.padded_data[i : i + 64] for i in range(0			,				len(self.padded_data)			,				64)
         ]


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			int)	->				List[Any]:




         """simple docstring"""

         lowercase__     =  list(struct.unpack('>16L'			,				lowerCAmelCase)) + [0] * 64
         for i in range(16			,				80):
               lowercase__     =  self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])			,				1)
         return w



   def 			UpperCAmelCase		(						self  :			str)	->				Dict:




         """simple docstring"""

         lowercase__     =  self.padding()
         lowercase__     =  self.split_blocks()
         for block in self.blocks:
               lowercase__     =  self.expand_block(lowerCAmelCase)
               lowercase__,	lowercase__,	lowercase__,	lowercase__,	lowercase__     =  self.h
               for i in range(0			,				80):
                     if 0 <= i < 20:
                           lowercase__     =  (b & c) | ((~b) & d)
                           lowercase__     =  0X5_A_8_2_7_9_9_9
                     elif 20 <= i < 40:
                           lowercase__     =  b ^ c ^ d
                           lowercase__     =  0X6_E_D_9_E_B_A_1
                     elif 40 <= i < 60:
                           lowercase__     =  (b & c) | (b & d) | (c & d)
                           lowercase__     =  0X8_F_1_B_B_C_D_C
                     elif 60 <= i < 80:
                           lowercase__     =  b ^ c ^ d
                           lowercase__     =  0XC_A_6_2_C_1_D_6
                     lowercase__,	lowercase__,	lowercase__,	lowercase__,	lowercase__     =  (
                         self.rotate(lowerCAmelCase			,				5) + f + e + k + expanded_block[i] & 0XF_F_F_F_F_F_F_F,
                         a,
                         self.rotate(lowerCAmelCase			,				30),
                         c,
                         d,
                     )
               lowercase__     =  (
                   self.h[0] + a & 0XF_F_F_F_F_F_F_F,
                   self.h[1] + b & 0XF_F_F_F_F_F_F_F,
                   self.h[2] + c & 0XF_F_F_F_F_F_F_F,
                   self.h[3] + d & 0XF_F_F_F_F_F_F_F,
                   self.h[4] + e & 0XF_F_F_F_F_F_F_F,
               )
         return ("{:08x}" * 5).format(*self.h)

def   _lowerCAmelCase   (						):
      lowercase__     =  B'Test String'
      assert SHAaHash(A__	).final_hash() == hashlib.shaa(A__	).hexdigest()  # noqa: S324

def   _lowerCAmelCase   (						):
      lowercase__     =  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'	)
      lowercase__     =  parser.parse_args()
      lowercase__     =  args.input_string
      # In any case hash input should be a bytestring
      if args.input_file:
            with open(args.input_file						,  'rb'	) as f:
                  lowercase__     =  f.read()
      else:
            lowercase__     =  bytes(A__						,  'utf-8'	)
      print(SHAaHash(A__	).final_hash()	)


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

       doctest.testmod()
