




import argparse
import struct
import unittest





class 	lowerCamelCase_							:


	'''simple docstring'''







	def __init__(							self  :		int    ,    _lowerCAmelCase  :		bytes						):
							SCREAMING_SNAKE_CASE_     						=      data

							# Initialize hash values
							SCREAMING_SNAKE_CASE_     						=      [
							    0x6a09_e667,
							    0xbb67_ae85,
							    0x3c6e_f372,
							    0xa54f_f53a,
							    0x510e_527f,
							    0x9b05_688c,
							    0x1f83_d9ab,
							    0x5be0_cd19,
							]

							# Initialize round constants
							SCREAMING_SNAKE_CASE_     						=      [
							    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,
							]

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



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



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

													SCREAMING_SNAKE_CASE_     						=      self.hashes

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

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

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

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

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

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

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




	def 				lowerCAmelCase_  (							self  :		List[Any]    ,    _lowerCAmelCase  :		int    ,    _lowerCAmelCase  :		int						):
							return 0xffff_ffff & (value << (32 - rotations)) | (value >> rotations)





class 	lowerCamelCase_							(				unittest.TestCase ):


	'''simple docstring'''







	def 				lowerCAmelCase_  (							self  :		List[str]						):
							import hashlib

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


def  UpperCAmelCase_							(				) ->			List[str]:
						import doctest

						doctest.testmod()

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

						SCREAMING_SNAKE_CASE_     						=      parser.parse_args()

						SCREAMING_SNAKE_CASE_     						=      args.input_string

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

						print(SHAaaa(lowerCAmelCase__							).hash							)


if __name__ == "__main__":
			main()





def  UpperCAmelCase_							(				__UpperCAmelCase						:     int      ,      __UpperCAmelCase						:     int							) ->			int:
      return int((input_a, input_a).count(0							) != 0							)

def  UpperCAmelCase_							(				) ->			None:
      assert nand_gate(0      ,      0							) == 1
      assert nand_gate(0      ,      1							) == 1
      assert nand_gate(1      ,      0							) == 1
      assert nand_gate(1      ,      1							) == 0


if __name__ == "__main__":
   print(nand_gate(0, 0))
   print(nand_gate(0, 1))
   print(nand_gate(1, 0))
   print(nand_gate(1, 1))