



'''simple docstring'''

import argparse
import struct
import unittest


class 	a__     :


	def __init__(self : str,					__UpperCAmelCase : bytes      )     ->			None:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= data

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

					SCREAMING_SNAKE_CASE  :						str      					= self.preprocessing(self.data      )
					self.final_hash()


	@staticmethod
	def 				lowercase__  (__UpperCAmelCase : bytes      )     ->			bytes:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						int      					= b'''\x80''' + (b'''\x00''' * (63 - (len(__UpperCAmelCase      ) + 8) % 64))
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= struct.pack('''>Q''',					(len(__UpperCAmelCase      ) * 8)      )
					return data + padding + big_endian_integer


	def 				lowercase__  (self : str      )     ->			None:

					"""simple docstring"""

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

									SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						str      					= self.hashes

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

																	SCREAMING_SNAKE_CASE  :						Any      					= (
																	    words[index - 16] + sa + words[index - 7] + sa
																	) % 0X100_000_000

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

													SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE  :						Dict      					= (
													    g,
													    f,
													    e,
													    ((d + tempa) % 0X100_000_000),
													    c,
													    b,
													    a,
													    ((tempa + tempa) % 0X100_000_000),
													)

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

									# Modify final values
									SCREAMING_SNAKE_CASE  :						str      					= [
									    ((element + mutated_hash_values[index]) % 0X100_000_000)
									    for index, element in enumerate(self.hashes      )
									]

					SCREAMING_SNAKE_CASE  :						str      					= ''''''.join([hex(__UpperCAmelCase      )[2:].zfill(8      ) for value in self.hashes]      )






	def 				lowercase__  (self : Tuple,					__UpperCAmelCase : int,					__UpperCAmelCase : int      )     ->			int:

					"""simple docstring"""

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



class 	a__     (				unittest.TestCase	):


	def 				lowercase__  (self : List[str]      )     ->			None:

					"""simple docstring"""

					import hashlib

					SCREAMING_SNAKE_CASE  :						Dict      					= bytes('''Test String''',					'''utf-8'''      )
					self.assertEqual(SHAaaa(__UpperCAmelCase      ).hash,					hashlib.shaaaa(__UpperCAmelCase      ).hexdigest()      )






def       __lowercase  ():
				import doctest

				doctest.testmod()

				SCREAMING_SNAKE_CASE  :						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'''       )

				SCREAMING_SNAKE_CASE  :						List[str]      					= parser.parse_args()

				SCREAMING_SNAKE_CASE  :						int      					= args.input_string

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

				print(SHAaaa(_SCREAMING_SNAKE_CASE       ).hash       )


if __name__ == "__main__":
	main()









'''simple docstring'''

from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case_			=     logging.get_logger(__name__)

snake_case_			=     {
    """facebook/nllb-moe-54B""": """https://huggingface.co/facebook/nllb-moe-54b/resolve/main/config.json""",
}


class 	a__     (				_lowercase	):
	__magic_name__		:    Optional[Any]	    =     "nllb-moe"
	__magic_name__		:    Optional[Any]	    =     ["past_key_values"]
	__magic_name__		:    Optional[int]	    =     {"num_attention_heads": "encoder_attention_heads", "hidden_size": "d_model"}


	def __init__(self : int,					__UpperCAmelCase : Tuple=128112,					__UpperCAmelCase : Any=1024,					__UpperCAmelCase : Optional[Any]=12,					__UpperCAmelCase : Optional[int]=4096,					__UpperCAmelCase : Any=16,					__UpperCAmelCase : Any=12,					__UpperCAmelCase : Optional[Any]=4096,					__UpperCAmelCase : Optional[int]=16,					__UpperCAmelCase : List[Any]=0.05,					__UpperCAmelCase : Dict=0.05,					__UpperCAmelCase : Dict=True,					__UpperCAmelCase : List[Any]=True,					__UpperCAmelCase : Any="relu",					__UpperCAmelCase : Union[str, Any]=1024,					__UpperCAmelCase : Optional[int]=0.1,					__UpperCAmelCase : Tuple=0.1,					__UpperCAmelCase : List[Any]=0.0,					__UpperCAmelCase : Optional[int]=0.02,					__UpperCAmelCase : Tuple=2,					__UpperCAmelCase : int=True,					__UpperCAmelCase : int=False,					__UpperCAmelCase : int="float32",					__UpperCAmelCase : Optional[Any]=False,					__UpperCAmelCase : List[str]=128,					__UpperCAmelCase : Dict=64,					__UpperCAmelCase : Dict=4,					__UpperCAmelCase : Optional[Any]=4,					__UpperCAmelCase : Optional[Any]=0.001,					__UpperCAmelCase : Optional[Any]=0.001,					__UpperCAmelCase : Optional[Any]="all",					__UpperCAmelCase : List[str]=False,					__UpperCAmelCase : Dict=False,					__UpperCAmelCase : Any=1.0,					__UpperCAmelCase : Dict=0.2,					__UpperCAmelCase : int=1,					__UpperCAmelCase : Union[str, Any]=0,					__UpperCAmelCase : Any=2,					__UpperCAmelCase : Union[str, Any]=False,					**__UpperCAmelCase : Dict,					)     ->			List[Any]:

					"""simple docstring"""

					SCREAMING_SNAKE_CASE  :						Any      					= vocab_size
					SCREAMING_SNAKE_CASE  :						int      					= max_position_embeddings
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= d_model
					SCREAMING_SNAKE_CASE  :						Dict      					= encoder_ffn_dim
					SCREAMING_SNAKE_CASE  :						int      					= encoder_layers
					SCREAMING_SNAKE_CASE  :						str      					= encoder_attention_heads
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= decoder_ffn_dim
					SCREAMING_SNAKE_CASE  :						str      					= decoder_layers
					SCREAMING_SNAKE_CASE  :						Dict      					= decoder_attention_heads
					SCREAMING_SNAKE_CASE  :						Dict      					= dropout
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= attention_dropout
					SCREAMING_SNAKE_CASE  :						Dict      					= activation_dropout
					SCREAMING_SNAKE_CASE  :						List[str]      					= activation_function
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= init_std
					SCREAMING_SNAKE_CASE  :						Any      					= encoder_layerdrop
					SCREAMING_SNAKE_CASE  :						Optional[int]      					= decoder_layerdrop
					SCREAMING_SNAKE_CASE  :						Dict      					= use_cache
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= encoder_layers
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= scale_embedding  # scale factor will be sqrt(d_model) if True
					SCREAMING_SNAKE_CASE  :						List[str]      					= router_z_loss_coef
					SCREAMING_SNAKE_CASE  :						List[str]      					= router_aux_loss_coef
					SCREAMING_SNAKE_CASE  :						int      					= decoder_sparse_step
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= encoder_sparse_step
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= num_experts
					SCREAMING_SNAKE_CASE  :						List[Any]      					= expert_capacity
					SCREAMING_SNAKE_CASE  :						Optional[Any]      					= router_bias
					if router_dtype not in ["float32", "float16", "bfloat16"]:
									raise ValueError(F'''`router_dtype` must be one of \'float32\', \'float16\' or \'bfloat16\', got {router_dtype}'''      )
					SCREAMING_SNAKE_CASE  :						Union[str, Any]      					= router_dtype

					SCREAMING_SNAKE_CASE  :						int      					= router_ignore_padding_tokens
					SCREAMING_SNAKE_CASE  :						Dict      					= batch_prioritized_routing
					SCREAMING_SNAKE_CASE  :						Dict      					= second_expert_policy
					SCREAMING_SNAKE_CASE  :						Tuple      					= normalize_router_prob_before_dropping
					SCREAMING_SNAKE_CASE  :						List[str]      					= moe_eval_capacity_token_fraction
					SCREAMING_SNAKE_CASE  :						List[Any]      					= moe_token_dropout
					SCREAMING_SNAKE_CASE  :						List[Any]      					= output_router_logits
					super().__init__(
					    pad_token_id=__UpperCAmelCase,					bos_token_id=__UpperCAmelCase,					eos_token_id=__UpperCAmelCase,					is_encoder_decoder=__UpperCAmelCase,					decoder_start_token_id=__UpperCAmelCase,					**__UpperCAmelCase,					)




