


'''simple docstring'''






import argparse
import struct
import unittest




class  a     :
 def __init__( self      ,				__magic_name__						)					->							None:
      _a			      =							data

      # Initialize hash values
      _a			      =							[
          0x6A09_E667,
          0xBB67_AE85,
          0x3C6E_F372,
          0xA54F_F53A,
          0x510E_527F,
          0x9B05_688C,
          0x1F83_D9AB,
          0x5BE0_CD19,
      ]

      # Initialize round constants
      _a			      =							[
          0x428A_2F98,
          0x7137_4491,
          0xB5C0_FBCF,
          0xE9B5_DBA5,
          0x3956_C25B,
          0x59F1_11F1,
          0x923F_82A4,
          0xAB1C_5ED5,
          0xD807_AA98,
          0x1283_5B01,
          0x2431_85BE,
          0x550C_7DC3,
          0x72BE_5D74,
          0x80DE_B1FE,
          0x9BDC_06A7,
          0xC19B_F174,
          0xE49B_69C1,
          0xEFBE_4786,
          0x0FC1_9DC6,
          0x240C_A1CC,
          0x2DE9_2C6F,
          0x4A74_84AA,
          0x5CB0_A9DC,
          0x76F9_88DA,
          0x983E_5152,
          0xA831_C66D,
          0xB003_27C8,
          0xBF59_7FC7,
          0xC6E0_0BF3,
          0xD5A7_9147,
          0x06CA_6351,
          0x1429_2967,
          0x27B7_0A85,
          0x2E1B_2138,
          0x4D2C_6DFC,
          0x5338_0D13,
          0x650A_7354,
          0x766A_0ABB,
          0x81C2_C92E,
          0x9272_2C85,
          0xA2BF_E8A1,
          0xA81A_664B,
          0xC24B_8B70,
          0xC76C_51A3,
          0xD192_E819,
          0xD699_0624,
          0xF40E_3585,
          0x106A_A070,
          0x19A4_C116,
          0x1E37_6C08,
          0x2748_774C,
          0x34B0_BCB5,
          0x391C_0CB3,
          0x4ED8_AA4A,
          0x5B9C_CA4F,
          0x682E_6FF3,
          0x748F_82EE,
          0x78A5_636F,
          0x84C8_7814,
          0x8CC7_0208,
          0x90BE_FFFA,
          0xA450_6CEB,
          0xBEF9_A3F7,
          0xC671_78F2,
      ]

      _a			      =							self.preprocessing(self.data						)
      self.final_hash()
 @staticmethod
 def 							__UpperCAmelCase		( __magic_name__						)					->							bytes:
      _a			      =							b'\x80' + (b'\x00' * (63 - (len(__magic_name__						) + 8) % 64))
      _a			      =							struct.pack('>Q'      ,				(len(__magic_name__						) * 8)						)
      return data + padding + big_endian_integer
 def 							__UpperCAmelCase		( self						)					->							None:
      # Convert into blocks of 64 bytes
      _a			      =							[
          self.preprocessed_data[x : x + 64]
          for x in range(0      ,				len(self.preprocessed_data						)      ,				64						)
      ]

      for block in self.blocks:
           # Convert the given block into a list of 4 byte integers
           _a			      =							list(struct.unpack('>16L'      ,				__magic_name__						)						)
           # add 48 0-ed integers
           words += [0] * 48

           _a      ,   _a      ,   _a      ,   _a      ,   _a      ,   _a      ,   _a      ,   _a			      =							self.hashes

           for index in range(0      ,				64						):
                if index > 15:
                     # modify the zero-ed indexes at the end of the array
                     _a			      =							(
                         self.ror(words[index - 15]      ,				7						)
                         ^ self.ror(words[index - 15]      ,				18						)
                         ^ (words[index - 15] >> 3)
                     )
                     _a			      =							(
                         self.ror(words[index - 2]      ,				17						)
                         ^ self.ror(words[index - 2]      ,				19						)
                         ^ (words[index - 2] >> 10)
                     )

                     _a			      =							(
                         words[index - 16] + sa + words[index - 7] + sa
                     ) % 0x1_0000_0000

                # Compression
                _a			      =							self.ror(__magic_name__      ,				6						) ^ self.ror(__magic_name__      ,				11						) ^ self.ror(__magic_name__      ,				25						)
                _a			      =							(e & f) ^ ((~e & 0xFFFF_FFFF) & g)
                _a			      =							(
                    h + sa + ch + self.round_constants[index] + words[index]
                ) % 0x1_0000_0000
                _a			      =							self.ror(__magic_name__      ,				2						) ^ self.ror(__magic_name__      ,				13						) ^ self.ror(__magic_name__      ,				22						)
                _a			      =							(a & b) ^ (a & c) ^ (b & c)
                _a			      =							(sa + maj) % 0x1_0000_0000

                _a      ,   _a      ,   _a      ,   _a      ,   _a      ,   _a      ,   _a      ,   _a			      =							(
                    g,
                    f,
                    e,
                    ((d + tempa) % 0x1_0000_0000),
                    c,
                    b,
                    a,
                    ((tempa + tempa) % 0x1_0000_0000),
                )

           _a			      =							[a, b, c, d, e, f, g, h]

           # Modify final values
           _a			      =							[
               ((element + mutated_hash_values[index]) % 0x1_0000_0000)
               for index, element in enumerate(self.hashes						)
           ]

      _a			      =							''.join([hex(__magic_name__						)[2:].zfill(8						) for value in self.hashes]						)




 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							int:
      return 0xFFFF_FFFF & (value << (32 - rotations)) | (value >> rotations)





class  a     (     unittest.TestCase       ):
 def 							__UpperCAmelCase		( self						)					->							None:
      import hashlib

      _a			      =							bytes('Test String'      ,				'utf-8'						)
      self.assertEqual(SHAaaa(__magic_name__						).hash      ,				hashlib.shaaaa(__magic_name__						).hexdigest()						)






def 	_A				()   ->  None:




     '''simple docstring'''



     import doctest

     doctest.testmod()

     _a			      =							argparse.ArgumentParser()
     parser.add_argument(
         '-s'				,						'--string'				,						dest='input_string'				,						default='Hello World!! Welcome to Cryptography'				,						help='Hash the string'				,						)
     parser.add_argument(
         '-f'				,						'--file'				,						dest='input_file'				,						help='Hash contents of a file'		)

     _a			      =							parser.parse_args()

     _a			      =							args.input_string

     # hash input should be a bytestring
     if args.input_file:
          with open(args.input_file				,						'rb'		) as f:
               _a			      =							f.read()
     else:
          _a			      =							bytes(lowerCAmelCase__				,						'utf-8'		)

     print(SHAaaa(lowerCAmelCase__		).hash		)


if __name__ == "__main__":
 main()





'''simple docstring'''






class  a     :
 def __init__( self						)					->							List[Any]:
      _a			      =							''
      _a			      =							''
      _a			      =							[]
 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							int:
      if m == -1:
           return n + 1
      elif n == -1:
           return m + 1
      elif self.dp[m][n] > -1:
           return self.dp[m][n]
      else:
           if self.worda[m] == self.worda[n]:
                _a			      =							self.__min_dist_top_down_dp(m - 1      ,				n - 1						)
           else:
                _a			      =							self.__min_dist_top_down_dp(__magic_name__      ,				n - 1						)
                _a			      =							self.__min_dist_top_down_dp(m - 1      ,				__magic_name__						)
                _a			      =							self.__min_dist_top_down_dp(m - 1      ,				n - 1						)
                _a			      =							1 + min(__magic_name__      ,				__magic_name__      ,				__magic_name__						)

           return self.dp[m][n]
 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							int:
      _a			      =							worda
      _a			      =							worda
      _a			      =							[[-1 for _ in range(len(__magic_name__						)						)] for _ in range(len(__magic_name__						)						)]

      return self.__min_dist_top_down_dp(len(__magic_name__						) - 1      ,				len(__magic_name__						) - 1						)




 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							int:
      _a			      =							worda
      _a			      =							worda
      _a			      =							len(__magic_name__						)
      _a			      =							len(__magic_name__						)
      _a			      =							[[0 for _ in range(n + 1						)] for _ in range(m + 1						)]

      for i in range(m + 1						):
           for j in range(n + 1						):
                if i == 0:  # first string is empty
                     _a			      =							j
                elif j == 0:  # second string is empty
                     _a			      =							i
                elif worda[i - 1] == worda[j - 1]:  # last characters are equal
                     _a			      =							self.dp[i - 1][j - 1]
                else:
                     _a			      =							self.dp[i][j - 1]
                     _a			      =							self.dp[i - 1][j]
                     _a			      =							self.dp[i - 1][j - 1]
                     _a			      =							1 + min(__magic_name__      ,				__magic_name__      ,				__magic_name__						)
      return self.dp[m][n]


if __name__ == "__main__":
 a_					:    Dict          =    EditDistance()

 print("****************** Testing Edit Distance DP Algorithm ******************")
 print()

 a_					:    Tuple          =    input("Enter the first string: ").strip()
 a_					:    Dict          =    input("Enter the second string: ").strip()

 print()
 print(f'''The minimum edit distance is: {solver.min_dist_top_down(Sa, Sa)}''')
 print(f'''The minimum edit distance is: {solver.min_dist_bottom_up(Sa, Sa)}''')
 print()
 print("*************** End of Testing Edit Distance DP Algorithm ***************")

