




import argparse
import struct
import unittest







class     __lowerCAmelCase :

			"""simple docstring"""







			def __init__(      self			,						lowerCamelCase__							)    ->      None:



							'''simple docstring'''
							__lowerCamelCase		       =    data

							# Initialize hash values
							__lowerCamelCase		       =    [
							    0x6a_09e_667,
							    0xbb_67a_e85,
							    0x3c_6ef_372,
							    0xa5_4ff_53a,
							    0x51_0e5_27f,
							    0x9b_056_88c,
							    0x1f_83d_9ab,
							    0x5b_e0c_d19,
							]

							# Initialize round constants
							__lowerCamelCase		       =    [
							    0x42_8a2_f98,
							    0x71_374_491,
							    0xb5_c0f_bcf,
							    0xe9_b5d_ba5,
							    0x39_56c_25b,
							    0x59_f11_1f1,
							    0x92_3f8_2a4,
							    0xab_1c5_ed5,
							    0xd8_07a_a98,
							    0x12_835_b01,
							    0x24_318_5be,
							    0x55_0c7_dc3,
							    0x72_be5_d74,
							    0x80_deb_1fe,
							    0x9b_dc0_6a7,
							    0xc1_9bf_174,
							    0xe4_9b6_9c1,
							    0xef_be4_786,
							    0x0f_c19_dc6,
							    0x24_0ca_1cc,
							    0x2d_e92_c6f,
							    0x4a_748_4aa,
							    0x5c_b0a_9dc,
							    0x76_f98_8da,
							    0x98_3e5_152,
							    0xa8_31c_66d,
							    0xb0_032_7c8,
							    0xbf_597_fc7,
							    0xc6_e00_bf3,
							    0xd5_a79_147,
							    0x06_ca6_351,
							    0x14_292_967,
							    0x27_b70_a85,
							    0x2e_1b2_138,
							    0x4d_2c6_dfc,
							    0x53_380_d13,
							    0x65_0a7_354,
							    0x76_6a0_abb,
							    0x81_c2c_92e,
							    0x92_722_c85,
							    0xa2_bfe_8a1,
							    0xa8_1a6_64b,
							    0xc2_4b8_b70,
							    0xc7_6c5_1a3,
							    0xd1_92e_819,
							    0xd6_990_624,
							    0xf4_0e3_585,
							    0x10_6aa_070,
							    0x19_a4c_116,
							    0x1e_376_c08,
							    0x27_487_74c,
							    0x34_b0b_cb5,
							    0x39_1c0_cb3,
							    0x4e_d8a_a4a,
							    0x5b_9cc_a4f,
							    0x68_2e6_ff3,
							    0x74_8f8_2ee,
							    0x78_a56_36f,
							    0x84_c87_814,
							    0x8c_c70_208,
							    0x90_bef_ffa,
							    0xa4_506_ceb,
							    0xbe_f9a_3f7,
							    0xc6_717_8f2,
							]

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


			@staticmethod
			def       lowercase_    (      lowerCamelCase__							)    ->      bytes:



							'''simple docstring'''
							__lowerCamelCase		       =    b'\x80' + (b'\x00' * (63 - (len(lowerCamelCase__							) + 8) % 64))
							__lowerCamelCase		       =    struct.pack('>Q'			,						(len(lowerCamelCase__							) * 8)							)
							return data + padding + big_endian_integer


			def       lowercase_    (      self							)    ->      None:



							'''simple docstring'''
							# Convert into blocks of 64 bytes
							__lowerCamelCase		       =    [
							    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
											__lowerCamelCase		       =    list(struct.unpack('>16L'			,						lowerCamelCase__							)							)
											# add 48 0-ed integers
											words += [0] * 48

											__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    self.hashes

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

																			__lowerCamelCase		       =    (
																			    words[index - 16] + sa + words[index - 7] + sa
																			) % 0x100_000_000

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

															__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase		       =    (
															    g,
															    f,
															    e,
															    ((d + tempa) % 0x100_000_000),
															    c,
															    b,
															    a,
															    ((tempa + tempa) % 0x100_000_000),
															)

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

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

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






			def       lowercase_    (      self			,						lowerCamelCase__			,						lowerCamelCase__							)    ->      int:



							'''simple docstring'''
							return 0xff_fff_fff & (value << (32 - rotations)) | (value >> rotations)







class     __lowerCAmelCase (       unittest.TestCase ):

			"""simple docstring"""







			def       lowercase_    (      self							)    ->      None:



							'''simple docstring'''
							import hashlib

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







def 			lowerCamelCase_		(       )     ->       None:





				"""simple docstring"""


				import doctest

				doctest.testmod()

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

				__lowerCamelCase		       =    parser.parse_args()

				__lowerCamelCase		       =    args.input_string

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

				print(SHAaaa(UpperCamelCase__      ).hash      )


if __name__ == "__main__":
					main()










"""simple docstring"""





from cva import destroyAllWindows, imread, imshow, waitKey







def      lowerCamelCase__       (							_lowerCamelCase       :		Tuple )      ->				Dict:
  # getting number of pixels in the image
  lowerCamelCase_     ,	lowerCamelCase_         =						img.shape[0], img.shape[1]

  # converting each pixel's color to its negative
  for i in range(_lowerCamelCase ):
    for j in range(_lowerCamelCase ):
      lowerCamelCase_         =						[255, 255, 255] - img[i][j]

  return img


if __name__ == "__main__":
  # read original image
  _SCREAMING_SNAKE_CASE					:				List[Any]					    =						imread('''image_data/lena.jpg''', 1)

  # convert to its negative
  _SCREAMING_SNAKE_CASE					:				List[Any]					    =						convert_to_negative(img)

  # show result image
  imshow('''negative of original image''', img)
  waitKey(0)
  destroyAllWindows()




