




'''simple docstring'''

import argparse
import struct
import unittest






class 		a							:


				def __init__(						self       :   Dict			,							lowercase_       :   bytes   ):
									snake_case_		     =							data

									# Initialize hash values
									snake_case_		     =							[
									    0X6_A_0_9_E_6_6_7,
									    0XB_B_6_7_A_E_8_5,
									    0X3_C_6_E_F_3_7_2,
									    0XA_5_4_F_F_5_3_A,
									    0X5_1_0_E_5_2_7_F,
									    0X9_B_0_5_6_8_8_C,
									    0X1_F_8_3_D_9_A_B,
									    0X5_B_E_0_C_D_1_9,
									]

									# Initialize round constants
									snake_case_		     =							[
									    0X4_2_8_A_2_F_9_8,
									    0X7_1_3_7_4_4_9_1,
									    0XB_5_C_0_F_B_C_F,
									    0XE_9_B_5_D_B_A_5,
									    0X3_9_5_6_C_2_5_B,
									    0X5_9_F_1_1_1_F_1,
									    0X9_2_3_F_8_2_A_4,
									    0XA_B_1_C_5_E_D_5,
									    0XD_8_0_7_A_A_9_8,
									    0X1_2_8_3_5_B_0_1,
									    0X2_4_3_1_8_5_B_E,
									    0X5_5_0_C_7_D_C_3,
									    0X7_2_B_E_5_D_7_4,
									    0X8_0_D_E_B_1_F_E,
									    0X9_B_D_C_0_6_A_7,
									    0XC_1_9_B_F_1_7_4,
									    0XE_4_9_B_6_9_C_1,
									    0XE_F_B_E_4_7_8_6,
									    0X0_F_C_1_9_D_C_6,
									    0X2_4_0_C_A_1_C_C,
									    0X2_D_E_9_2_C_6_F,
									    0X4_A_7_4_8_4_A_A,
									    0X5_C_B_0_A_9_D_C,
									    0X7_6_F_9_8_8_D_A,
									    0X9_8_3_E_5_1_5_2,
									    0XA_8_3_1_C_6_6_D,
									    0XB_0_0_3_2_7_C_8,
									    0XB_F_5_9_7_F_C_7,
									    0XC_6_E_0_0_B_F_3,
									    0XD_5_A_7_9_1_4_7,
									    0X0_6_C_A_6_3_5_1,
									    0X1_4_2_9_2_9_6_7,
									    0X2_7_B_7_0_A_8_5,
									    0X2_E_1_B_2_1_3_8,
									    0X4_D_2_C_6_D_F_C,
									    0X5_3_3_8_0_D_1_3,
									    0X6_5_0_A_7_3_5_4,
									    0X7_6_6_A_0_A_B_B,
									    0X8_1_C_2_C_9_2_E,
									    0X9_2_7_2_2_C_8_5,
									    0XA_2_B_F_E_8_A_1,
									    0XA_8_1_A_6_6_4_B,
									    0XC_2_4_B_8_B_7_0,
									    0XC_7_6_C_5_1_A_3,
									    0XD_1_9_2_E_8_1_9,
									    0XD_6_9_9_0_6_2_4,
									    0XF_4_0_E_3_5_8_5,
									    0X1_0_6_A_A_0_7_0,
									    0X1_9_A_4_C_1_1_6,
									    0X1_E_3_7_6_C_0_8,
									    0X2_7_4_8_7_7_4_C,
									    0X3_4_B_0_B_C_B_5,
									    0X3_9_1_C_0_C_B_3,
									    0X4_E_D_8_A_A_4_A,
									    0X5_B_9_C_C_A_4_F,
									    0X6_8_2_E_6_F_F_3,
									    0X7_4_8_F_8_2_E_E,
									    0X7_8_A_5_6_3_6_F,
									    0X8_4_C_8_7_8_1_4,
									    0X8_C_C_7_0_2_0_8,
									    0X9_0_B_E_F_F_F_A,
									    0XA_4_5_0_6_C_E_B,
									    0XB_E_F_9_A_3_F_7,
									    0XC_6_7_1_7_8_F_2,
									]

									snake_case_		     =							self.preprocessing(self.data   )
									self.final_hash()


				@staticmethod
				def     A_					(						lowercase_       :   bytes   ):
									snake_case_		     =							B'''\x80''' + (B'''\x00''' * (63 - (len(lowercase_   ) + 8) % 64))
									snake_case_		     =							struct.pack('''>Q'''			,							(len(lowercase_   ) * 8)   )
									return data + padding + big_endian_integer


				def     A_					(						self       :   int   ):
									# Convert into blocks of 64 bytes
									snake_case_		     =							[
									    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
														snake_case_		     =							list(struct.unpack('''>16L'''			,							lowercase_   )   )
														# add 48 0-ed integers
														words += [0] * 48

														snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							self.hashes

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

																								snake_case_		     =							(
																								    words[index - 16] + sa + words[index - 7] + sa
																								) % 0X1_0_0_0_0_0_0_0_0

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

																			snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_     ,snake_case_		     =							(
																			    g,
																			    f,
																			    e,
																			    ((d + tempa) % 0X1_0_0_0_0_0_0_0_0),
																			    c,
																			    b,
																			    a,
																			    ((tempa + tempa) % 0X1_0_0_0_0_0_0_0_0),
																			)

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

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

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


				def     A_					(						self       :   Union[str, Any]			,							lowercase_       :   int			,							lowercase_       :   int   ):
									return 0XF_F_F_F_F_F_F_F & (value << (32 - rotations)) | (value >> rotations)







class 		a							(  unittest.TestCase	):


				def     A_					(						self       :   Optional[int]   ):
									import hashlib

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







def 						__magic_name__       (      )						->   None:

					'''simple docstring'''

					import doctest

					doctest.testmod()

					snake_case_		     =							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'''      )

					snake_case_		     =							parser.parse_args()

					snake_case_		     =							args.input_string

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

					print(SHAaaa(__UpperCAmelCase      ).hash      )


if __name__ == "__main__":
							main()







'''simple docstring'''

from ....utils import logging


a    :							Optional[int]										=    logging.get_logger(__name__)






class 		a							(  _lowerCamelCase	):


				def __init__(						self       :   int			,							lowercase_       :   Tuple			,							lowercase_       :   Any=None			,							lowercase_       :   List[Any]=2048   ):
									snake_case_		     =							config.__dict__
									snake_case_		     =							modal_hidden_size
									if num_labels:
														snake_case_		     =							num_labels

