"""simple docstring"""


import argparse
import struct
import unittest






class   __UpperCAmelCase		:

				def __init__( self      ,					_lowerCamelCase ):
										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 						_a      ( _lowerCamelCase ):
										lowerCamelCase__   =b"\x80" + (b"\x00" * (63 - (len(_lowerCamelCase ) + 8) % 64))
										lowerCamelCase__   =struct.pack(">Q"      ,					(len(_lowerCamelCase ) * 8) )
										return data + padding + big_endian_integer

				def 						_a      ( self ):
										# 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 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										return 0Xff_fff_fff & (value << (32 - rotations)) | (value >> rotations)






class   __UpperCAmelCase		(      unittest.TestCase      ):

				def 						_a      ( self ):
										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(__lowerCAmelCase  ,       "utf-8"							)

						print(SHAaaa(__lowerCAmelCase							).hash							)


if __name__ == "__main__":
	main()



"""simple docstring"""


import fire

from transformers import AutoConfig, AutoModelForSeqaSeqLM, AutoTokenizer





def      lowerCamelCase_					(   __lowerCAmelCase  ,       __lowerCAmelCase  ,       **__lowerCAmelCase							)				->   List[str]:




						'''simple docstring'''



						lowerCamelCase__   =AutoConfig.from_pretrained(__lowerCAmelCase  ,       **__lowerCAmelCase							)
						lowerCamelCase__   =AutoModelForSeqaSeqLM.from_config(__lowerCAmelCase							)
						model.save_pretrained(__lowerCAmelCase							)
						AutoTokenizer.from_pretrained(__lowerCAmelCase							).save_pretrained(__lowerCAmelCase							)
						return model


if __name__ == "__main__":
	fire.Fire(save_randomly_initialized_version)


