





"""simple docstring"""






import argparse
import struct
import unittest




class 					__lowercase      :







					'''simple docstring'''




					def __init__(    self						,      _UpperCAmelCase  ):
									__a			:    Any      							=	data

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

									# Initialize round constants
									__a			:    Union[str, Any]      							=	[
									    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			:    Tuple      							=	self.preprocessing(self.data  )
									self.final_hash()







					@staticmethod
					def 			_lowerCamelCase		(    _UpperCAmelCase  ):
									__a			:    Union[str, Any]      							=	b'''\x80''' + (b'''\x00''' * (63 - (len(_UpperCAmelCase  ) + 8) % 64))
									__a			:    Tuple      							=	struct.pack('''>Q'''						,      (len(_UpperCAmelCase  ) * 8)  )
									return data + padding + big_endian_integer







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

													__a							,    __a							,    __a							,    __a							,    __a							,    __a							,    __a							,    __a			:    str      							=	self.hashes

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

																					__a			:    Optional[int]      							=	(
																					    words[index - 16] + sa + words[index - 7] + sa
																					) % 0x1_0000_0000

																	# Compression
																	__a			:    int      							=	self.ror(_UpperCAmelCase						,      6  ) ^ self.ror(_UpperCAmelCase						,      11  ) ^ self.ror(_UpperCAmelCase						,      25  )
																	__a			:    Optional[int]      							=	(e & f) ^ ((~e & 0xffff_ffff) & g)
																	__a			:    Dict      							=	(
																	    h + sa + ch + self.round_constants[index] + words[index]
																	) % 0x1_0000_0000
																	__a			:    Tuple      							=	self.ror(_UpperCAmelCase						,      2  ) ^ self.ror(_UpperCAmelCase						,      13  ) ^ self.ror(_UpperCAmelCase						,      22  )
																	__a			:    Optional[int]      							=	(a & b) ^ (a & c) ^ (b & c)
																	__a			:    Any      							=	(sa + maj) % 0x1_0000_0000

																	__a							,    __a							,    __a							,    __a							,    __a							,    __a							,    __a							,    __a			:    Optional[Any]      							=	(
																	    g,
																	    f,
																	    e,
																	    ((d + tempa) % 0x1_0000_0000),
																	    c,
																	    b,
																	    a,
																	    ((tempa + tempa) % 0x1_0000_0000),
																	)

													__a			:    Tuple      							=	[a, b, c, d, e, f, g, h]

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

									__a			:    List[Any]      							=	''''''.join([hex(_UpperCAmelCase  )[2:].zfill(8  ) for value in self.hashes]  )







					def 			_lowerCamelCase		(    self						,      _UpperCAmelCase						,      _UpperCAmelCase  ):
									return 0xffff_ffff & (value << (32 - rotations)) | (value >> rotations)






class 					__lowercase      (      unittest.TestCase				):







					'''simple docstring'''




					def 			_lowerCamelCase		(    self  ):
									import hashlib

									__a			:    Any      							=	bytes('''Test String'''						,      '''utf-8'''  )
									self.assertEqual(SHAaaa(_UpperCAmelCase  ).hash						,      hashlib.shaaaa(_UpperCAmelCase  ).hexdigest()  )






def      __A   (      )		->		None:
				import doctest

				doctest.testmod()

				__a			:    List[Any]      							=	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			:    Dict      							=	parser.parse_args()

				__a			:    Dict      							=	args.input_string

				# hash input should be a bytestring
				if args.input_file:
								with open(args.input_file ,							'''rb''') as f:
												__a			:    Any      							=	f.read()
				else:
								__a			:    Optional[Any]      							=	bytes(a_ ,							'''utf-8''')

				print(SHAaaa(a_).hash)


if __name__ == "__main__":
		main()
'''simple docstring'''




def __lowerCAmelCase					(				)      ->       Optional[Any]:
    __lowerCamelCase            =    0
    for i in range(1							,    10_01							):
        total += i**i
    return str(UpperCamelCase__							)[-10:]


if __name__ == "__main__":
  print(solution())
