
import argparse
import hashlib  # hashlib is only used inside the Test class
import struct




class        _SCREAMING_SNAKE_CASE	:



	def __init__(       self		,    lowercase					)							->			str:
					lowerCamelCase_         =     data
					lowerCamelCase_         =     [0x67_452_301, 0xef_cda_b89, 0x98_bad_cfe, 0x10_325_476, 0xc3_d2e_1f0]



	@staticmethod
	def        SCREAMING_SNAKE_CASE_(       lowercase		,    lowercase					)							->			Union[str, Any]:
					return ((n << b) | (n >> (32 - b))) & 0xff_fff_fff



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Dict:
					lowerCamelCase_         =     b"\x80" + b"\x00" * (63 - (len(self.data					) + 8) % 64)
					lowerCamelCase_         =     self.data + padding + struct.pack(">Q"		,    8 * len(self.data					)					)
					return padded_data



	def        SCREAMING_SNAKE_CASE_(       self					)							->			List[str]:
					return [
					    self.padded_data[i : i + 64] for i in range(0		,    len(self.padded_data					)		,    64					)
					]



	def        SCREAMING_SNAKE_CASE_(       self		,    lowercase					)							->			Union[str, Any]:
					lowerCamelCase_         =     list(struct.unpack(">16L"		,    lowercase					)					) + [0] * 64
					for i in range(16		,    80					):
									lowerCamelCase_         =     self.rotate((w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16])		,    1					)
					return w



	def        SCREAMING_SNAKE_CASE_(       self					)							->			Tuple:
					lowerCamelCase_         =     self.padding()
					lowerCamelCase_         =     self.split_blocks()
					for block in self.blocks:
									lowerCamelCase_         =     self.expand_block(lowercase					)
									lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     self.h
									for i in range(0		,    80					):
													if 0 <= i < 20:
																	lowerCamelCase_         =     (b & c) | ((~b) & d)
																	lowerCamelCase_         =     0x5a_827_999
													elif 20 <= i < 40:
																	lowerCamelCase_         =     b ^ c ^ d
																	lowerCamelCase_         =     0x6e_d9e_ba1
													elif 40 <= i < 60:
																	lowerCamelCase_         =     (b & c) | (b & d) | (c & d)
																	lowerCamelCase_         =     0x8f_1bb_cdc
													elif 60 <= i < 80:
																	lowerCamelCase_         =     b ^ c ^ d
																	lowerCamelCase_         =     0xca_62c_1d6
													lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_      ,       lowerCamelCase_         =     (
													    self.rotate(lowercase		,    5					) + f + e + k + expanded_block[i] & 0xff_fff_fff,
													    a,
													    self.rotate(lowercase		,    30					),
													    c,
													    d,
													)
									lowerCamelCase_         =     (
									    self.h[0] + a & 0xff_fff_fff,
									    self.h[1] + b & 0xff_fff_fff,
									    self.h[2] + c & 0xff_fff_fff,
									    self.h[3] + d & 0xff_fff_fff,
									    self.h[4] + e & 0xff_fff_fff,
									)
					return ("{:08x}" * 5).format(*self.h					)





def      lowerCamelCase_					(							):
				lowerCamelCase_         =     b"Test String"
				assert SHAaHash(lowerCamelCase__       ).final_hash() == hashlib.shaa(lowerCamelCase__       ).hexdigest()  # noqa: S324





def      lowerCamelCase_					(							):
				lowerCamelCase_         =     argparse.ArgumentParser(description="Process some strings or files"       )
				parser.add_argument(
				    "--string"      ,					dest="input_string"      ,					default="Hello World!! Welcome to Cryptography"      ,					help="Hash the string"      ,					)
				parser.add_argument("--file"      ,					dest="input_file"      ,					help="Hash contents of a file"       )
				lowerCamelCase_         =     parser.parse_args()
				lowerCamelCase_         =     args.input_string
				# In any case hash input should be a bytestring
				if args.input_file:
								with open(args.input_file      ,					"rb"       ) as f:
												lowerCamelCase_         =     f.read()
				else:
								lowerCamelCase_         =     bytes(lowerCamelCase__      ,					"utf-8"       )
				print(SHAaHash(lowerCamelCase__       ).final_hash()       )


if __name__ == "__main__":
			main()
			import doctest

			doctest.testmod()




import math





def      lowerCamelCase_					(							lowerCamelCase__      ,					lowerCamelCase__       ):
				if 0 not in (x, y):
								# We use the relation x^y = y*log10(x), where 10 is the base.
								return y * math.logaa(lowerCamelCase__       )
				else:
								if x == 0:  # 0 raised to any number is 0
												return 0
								elif y == 0:
												return 1  # any number raised to 0 is 1
				raise AssertionError("This should never happen"       )


if __name__ == "__main__":  # Main function
			# Read two numbers from input and typecast them to int using map function.
			# Here x is the base and y is the power.
			__A							='''Enter the base and the power separated by a comma: '''
			__A,		__A							=map(int, input(prompt).split(''','''))
			__A,		__A							=map(int, input(prompt).split(''','''))

			# We find the log of each number, using the function res(), which takes two
			# arguments.
			__A							=res(xa, ya)
			__A							=res(xa, ya)

			# We check for the largest number
			if resa > resa:
						print('''Largest number is''', xa, '''^''', ya)
			elif resa > resa:
						print('''Largest number is''', xa, '''^''', ya)
			else:
						print('''Both are equal''')


