


"""simple docstring"""






import argparse
import struct
import unittest






class      A:

		"""simple docstring"""





		def __init__( self					,				SCREAMING_SNAKE_CASE__   )      ->	None:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	data

					# Initialize hash values
					_UpperCamelCase					:Optional[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
					_UpperCamelCase					: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,
					]

					_UpperCamelCase					:Optional[Any]					     =	self.preprocessing(self.data   )
					self.final_hash()
		@staticmethod
		def   _UpperCamelCase( SCREAMING_SNAKE_CASE__   )      ->	bytes:

					"""simple docstring"""



					_UpperCamelCase					:Tuple					     =	b'''\x80''' + (b'''\x00''' * (63 - (len(SCREAMING_SNAKE_CASE__   ) + 8) % 64))
					_UpperCamelCase					:Any					     =	struct.pack('''>Q'''					,				(len(SCREAMING_SNAKE_CASE__   ) * 8)   )
					return data + padding + big_endian_integer
		def   _UpperCamelCase( self   )      ->	None:

					"""simple docstring"""



					_UpperCamelCase					:Optional[int]					     =	[
					    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
								_UpperCamelCase					:Optional[int]					     =	list(struct.unpack('''>16L'''					,				SCREAMING_SNAKE_CASE__   )   )
								# add 48 0-ed integers
								words += [0] * 48

								_UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase					:str					     =	self.hashes

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

														_UpperCamelCase					:List[Any]					     =	(
														    words[index - 16] + sa + words[index - 7] + sa
														) % 0X1_0_0_0_0_0_0_0_0

											# Compression
											_UpperCamelCase					:List[str]					     =	self.ror(SCREAMING_SNAKE_CASE__					,				6   ) ^ self.ror(SCREAMING_SNAKE_CASE__					,				11   ) ^ self.ror(SCREAMING_SNAKE_CASE__					,				25   )
											_UpperCamelCase					:Tuple					     =	(e & f) ^ ((~e & 0XF_F_F_F_F_F_F_F) & g)
											_UpperCamelCase					:Union[str, Any]					     =	(
											    h + sa + ch + self.round_constants[index] + words[index]
											) % 0X1_0_0_0_0_0_0_0_0
											_UpperCamelCase					:Optional[int]					     =	self.ror(SCREAMING_SNAKE_CASE__					,				2   ) ^ self.ror(SCREAMING_SNAKE_CASE__					,				13   ) ^ self.ror(SCREAMING_SNAKE_CASE__					,				22   )
											_UpperCamelCase					:Any					     =	(a & b) ^ (a & c) ^ (b & c)
											_UpperCamelCase					:Optional[Any]					     =	(sa + maj) % 0X1_0_0_0_0_0_0_0_0

											_UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase     ,      _UpperCamelCase					:List[str]					     =	(
											    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),
											)

								_UpperCamelCase					:Any					     =	[a, b, c, d, e, f, g, h]

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

					_UpperCamelCase					:Optional[int]					     =	''''''.join([hex(SCREAMING_SNAKE_CASE__   )[2:].zfill(8   ) for value in self.hashes]   )





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	int:

					"""simple docstring"""



					return 0XF_F_F_F_F_F_F_F & (value << (32 - rotations)) | (value >> rotations)






class      A(  unittest.TestCase		):

		"""simple docstring"""





		def   _UpperCamelCase( self   )      ->	None:

					"""simple docstring"""



					import hashlib

					_UpperCamelCase					: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()

			_UpperCamelCase					:str					     =	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'''		)

			_UpperCamelCase					:Dict					     =	parser.parse_args()

			_UpperCamelCase					:Optional[int]					     =	args.input_string

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

			print(SHAaaa(snake_case__		).hash		)


if __name__ == "__main__":
					main()





"""simple docstring"""






import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate





def 				A_       ( snake_case__		)					->  Union[str, Any]:
			return x + 2






class      A(  unittest.TestCase		):

		"""simple docstring"""





		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	'''x = 3'''
					_UpperCamelCase					:List[str]					     =	{}
					_UpperCamelCase					:int					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3}   )

					_UpperCamelCase					:Tuple					     =	'''x = y'''
					_UpperCamelCase					:Optional[int]					     =	{'''y''': 5}
					_UpperCamelCase					:Optional[Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 5, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''y = add_two(x)'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )

					# Won't work without the tool
					with CaptureStdout() as out:
								_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result is None
					assert "tried to execute add_two" in out.out
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Any					     =	'''x = 3'''
					_UpperCamelCase					:int					     =	{}
					_UpperCamelCase					:List[Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3}   )
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''test_dict = {\'x\': x, \'y\': add_two(x)}'''
					_UpperCamelCase					:str					     =	{'''x''': 3}
					_UpperCamelCase					:Dict					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	'''x = 3\ny = 5'''
					_UpperCamelCase					:int					     =	{}
					_UpperCamelCase					:Optional[int]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	'''text = f\'This is x: {x}.\''''
					_UpperCamelCase					:List[str]					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == "This is x: 3."
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''text''': '''This is x: 3.'''}   )
		def   _UpperCamelCase( self   )      ->	Union[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:Optional[Any]					     =	'''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
					_UpperCamelCase					:Dict					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 2
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 2}   )

					_UpperCamelCase					:Union[str, Any]					     =	{'''x''': 8}
					_UpperCamelCase					:Optional[int]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 8, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	'''test_list = [x, add_two(x)]'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:str					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					self.assertListEqual(SCREAMING_SNAKE_CASE__					,				[3, 5]   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_list''': [3, 5]}   )
		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					_UpperCamelCase					:List[Any]					     =	'''y = x'''
					_UpperCamelCase					:List[str]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 3}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:Tuple					     =	'''test_list = [x, add_two(x)]\ntest_list[1]'''
					_UpperCamelCase					:Optional[Any]					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_list''': [3, 5]}   )

					_UpperCamelCase					:str					     =	'''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )





		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''x = 0\nfor i in range(3):\n    x = i'''
					_UpperCamelCase					:Tuple					     =	{}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''range''': range}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 2
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 2, '''i''': 2}   )

