






"""simple docstring"""





import argparse
import struct
import unittest



class       __A		:

					def __init__(			self  :      str     ,		__snake_case  :      bytes					)			->							None:
											__magic_name__:	List[Any]							=       data

											# Initialize hash values
											__magic_name__:	Union[str, Any]							=       [
											    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
											__magic_name__:	List[str]							=       [
											    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,
											]

											__magic_name__:	Tuple							=       self.preprocessing(self.data					)
											self.final_hash()

					@staticmethod
					def   lowerCamelCase__   (			__snake_case  :      bytes					)			->							bytes:
											__magic_name__:	int							=       b"\x80" + (b"\x00" * (6_3 - (len(_SCREAMING_SNAKE_CASE					) + 8) % 6_4))
											__magic_name__:	Union[str, Any]							=       struct.pack(""">Q"""     ,		(len(_SCREAMING_SNAKE_CASE					) * 8)					)
											return data + padding + big_endian_integer

					def   lowerCamelCase__   (			self  :      Dict					)			->							None:
											__magic_name__:	str							=       [
											    self.preprocessed_data[x : x + 6_4]
											    for x in range(0     ,		len(self.preprocessed_data					)     ,		6_4					)
											]

											for block in self.blocks:
																	# Convert the given block into a list of 4 byte integers
																	__magic_name__:	Dict							=       list(struct.unpack(""">16L"""     ,		_SCREAMING_SNAKE_CASE					)					)
																	# add 48 0-ed integers
																	words += [0] * 4_8

																	__magic_name__:	Optional[Any]							=       self.hashes

																	for index in range(0     ,		6_4					):
																							if index > 1_5:
																													# modify the zero-ed indexes at the end of the array
																													__magic_name__:	Optional[Any]							=       (
																													    self.ror(words[index - 1_5]     ,		7					)
																													    ^ self.ror(words[index - 1_5]     ,		1_8					)
																													    ^ (words[index - 1_5] >> 3)
																													)
																													__magic_name__:	Union[str, Any]							=       (
																													    self.ror(words[index - 2]     ,		1_7					)
																													    ^ self.ror(words[index - 2]     ,		1_9					)
																													    ^ (words[index - 2] >> 1_0)
																													)

																													__magic_name__:	Dict							=       (
																													    words[index - 1_6] + sa + words[index - 7] + sa
																													) % 0X1_0_0_0_0_0_0_0_0

																							# Compression
																							__magic_name__:	Optional[int]							=       self.ror(_SCREAMING_SNAKE_CASE     ,		6					) ^ self.ror(_SCREAMING_SNAKE_CASE     ,		1_1					) ^ self.ror(_SCREAMING_SNAKE_CASE     ,		2_5					)
																							__magic_name__:	Optional[Any]							=       (e & f) ^ ((~e & 0XF_F_F_F_F_F_F_F) & g)
																							__magic_name__:	Optional[int]							=       (
																							    h + sa + ch + self.round_constants[index] + words[index]
																							) % 0X1_0_0_0_0_0_0_0_0
																							__magic_name__:	Dict							=       self.ror(_SCREAMING_SNAKE_CASE     ,		2					) ^ self.ror(_SCREAMING_SNAKE_CASE     ,		1_3					) ^ self.ror(_SCREAMING_SNAKE_CASE     ,		2_2					)
																							__magic_name__:	Any							=       (a & b) ^ (a & c) ^ (b & c)
																							__magic_name__:	List[Any]							=       (sa + maj) % 0X1_0_0_0_0_0_0_0_0

																							__magic_name__:	Tuple							=       (
																							    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),
																							)

																	__magic_name__:	Optional[int]							=       [a, b, c, d, e, f, g, h]

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

											__magic_name__:	Dict							=       "".join([hex(_SCREAMING_SNAKE_CASE					)[2:].zfill(8					) for value in self.hashes]					)






					def   lowerCamelCase__   (			self  :      Optional[int]     ,		__snake_case  :      int     ,		__snake_case  :      int					)			->							int:
											return 0XF_F_F_F_F_F_F_F & (value << (3_2 - rotations)) | (value >> rotations)



class       __A		(   unittest.TestCase			):

					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							None:
											import hashlib

											__magic_name__:	Union[str, Any]							=       bytes("""Test String"""     ,		"""utf-8"""					)
											self.assertEqual(SHAaaa(_SCREAMING_SNAKE_CASE					).hash     ,		hashlib.shaaaa(_SCREAMING_SNAKE_CASE					).hexdigest()					)



def   a    (     )    ->							None:
						import doctest

						doctest.testmod()

						__magic_name__:	int							=       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"""  )

						__magic_name__:	Any							=       parser.parse_args()

						__magic_name__:	Tuple							=       args.input_string

						# hash input should be a bytestring
						if args.input_file:
												with open(args.input_file      ,   """rb"""  ) as f:
																		__magic_name__:	Union[str, Any]							=       f.read()
						else:
												__magic_name__:	Optional[Any]							=       bytes(__snake_case      ,   """utf-8"""  )

						print(SHAaaa(__snake_case  ).hash  )


if __name__ == "__main__":
							main()








"""simple docstring"""






def      _lowercase							(    __snake_case      )		->  float:
			return 10 - x * x


def      _lowercase							(    __snake_case   ,__snake_case      )		->  float:
			# Bolzano theory in order to find if there is a root between a and b
			if equation(__snake_case      ) * equation(__snake_case      ) >= 0:
						raise ValueError("Wrong space!"      )

			__lowerCAmelCase :    List[Any]				=			a
			while (b - a) >= 0.01:
						# Find middle point
						__lowerCAmelCase :    str				=			(a + b) / 2
						# Check if middle point is root
						if equation(__snake_case      ) == 0.0:
									break
						# Decide the side to repeat the steps
						if equation(__snake_case      ) * equation(__snake_case      ) < 0:
									__lowerCAmelCase :    List[Any]				=			c
						else:
									__lowerCAmelCase :    List[str]				=			c
			return c


if __name__ == "__main__":
	import doctest

	doctest.testmod()

	print(bisection(-2, 5))
	print(bisection(0, 6))