


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






def 	_A				(lowerCAmelCase__  :Union[str, Any]		)   ->  List[str]:




     '''simple docstring'''



     return [
         {
             0: [1, 2],
             1: [0, 2],
             2: [0, 1, 3, 5],
             3: [2, 4],
             4: [3],
             5: [2, 6, 8],
             6: [5, 7],
             7: [6, 8],
             8: [5, 7],
         },
         {
             0: [6],
             1: [9],
             2: [4, 5],
             3: [4],
             4: [2, 3],
             5: [2],
             6: [0, 7],
             7: [6],
             8: [],
             9: [1],
         },
         {
             0: [4],
             1: [6],
             2: [],
             3: [5, 6, 7],
             4: [0, 6],
             5: [3, 8, 9],
             6: [1, 3, 4, 7],
             7: [3, 6, 8, 9],
             8: [5, 7],
             9: [5, 7],
         },
         {
             0: [1, 3],
             1: [0, 2, 4],
             2: [1, 3, 4],
             3: [0, 2, 4],
             4: [1, 2, 3],
         },
     ][index]






def 	_A				(lowerCAmelCase__  :dict[int, list[int]]		)   ->  list[tuple[int, int]]:




     '''simple docstring'''



     _a			      =							0
     _a			      =							len(lowerCAmelCase__		)  # No of vertices in graph
     _a			      =							[0] * n
     _a			      =							[False] * n

     def dfs(lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :str				,						lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :Union[str, Any]		):
          _a			      =							True
          _a			      =							id_
          id_ += 1
          for to in graph[at]:
               if to == parent:
                    pass
               elif not visited[to]:
                    dfs(lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__				,						id_		)
                    _a			      =							min(low[at]				,						low[to]		)
                    if id_ <= low[to]:
                         bridges.append((at, to) if at < to else (to, at)		)
               else:
                    # This edge is a back edge and cannot be a bridge
                    _a			      =							min(low[at]				,						low[to]		)

     _a			      =							[]
     for i in range(lowerCAmelCase__		):
          if not visited[i]:
               dfs(lowerCAmelCase__				,						-1				,						lowerCAmelCase__				,						id_		)
     return bridges


if __name__ == "__main__":
 import doctest

 doctest.testmod()

