



from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
			import tensorflow as tf

			from transformers import TFLEDForConditionalGeneration, TFLEDModel

@require_tf
class   UpperCAmelCase_    :

						'''simple docstring'''




						UpperCamelCase__     :					Optional[Any]							    =    LEDConfig
						UpperCamelCase__     :					Dict							    =    {}
						UpperCamelCase__     :					Optional[int]							    =    '''gelu'''






						def __init__(       self ,				_A ,				_A=13 ,				_A=7 ,				_A=True ,				_A=False ,				_A=99 ,				_A=32 ,				_A=2 ,				_A=4 ,				_A=37 ,				_A=0.1 ,				_A=0.1 ,				_A=20 ,				_A=2 ,				_A=1 ,				_A=0 ,				_A=4 ,				):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   parent
													__SCREAMING_SNAKE_CASE										=   batch_size
													__SCREAMING_SNAKE_CASE										=   seq_length
													__SCREAMING_SNAKE_CASE										=   is_training
													__SCREAMING_SNAKE_CASE										=   use_labels
													__SCREAMING_SNAKE_CASE										=   vocab_size
													__SCREAMING_SNAKE_CASE										=   hidden_size
													__SCREAMING_SNAKE_CASE										=   num_hidden_layers
													__SCREAMING_SNAKE_CASE										=   num_attention_heads
													__SCREAMING_SNAKE_CASE										=   intermediate_size

													__SCREAMING_SNAKE_CASE										=   hidden_dropout_prob
													__SCREAMING_SNAKE_CASE										=   attention_probs_dropout_prob
													__SCREAMING_SNAKE_CASE										=   max_position_embeddings
													__SCREAMING_SNAKE_CASE										=   eos_token_id
													__SCREAMING_SNAKE_CASE										=   pad_token_id
													__SCREAMING_SNAKE_CASE										=   bos_token_id
													__SCREAMING_SNAKE_CASE										=   attention_window

													# `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
													# [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
													# returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
													# because its local attention only attends to `self.attention_window` and one before and one after
													__SCREAMING_SNAKE_CASE										=   self.attention_window + 2

													# because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
													# the `test_attention_outputs` and `test_hidden_states_output` tests
													__SCREAMING_SNAKE_CASE										=   (
													    self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
													)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   ids_tensor([self.batch_size, self.seq_length - 1] ,				self.vocab_size						)
													__SCREAMING_SNAKE_CASE										=   tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size						) ,				1						)
													__SCREAMING_SNAKE_CASE										=   tf.concat([input_ids, eos_tensor] ,				axis=1						)

													__SCREAMING_SNAKE_CASE										=   ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size						)

													__SCREAMING_SNAKE_CASE										=   self.config_cls(
													    vocab_size=self.vocab_size ,				d_model=self.hidden_size ,				encoder_layers=self.num_hidden_layers ,				decoder_layers=self.num_hidden_layers ,				encoder_attention_heads=self.num_attention_heads ,				decoder_attention_heads=self.num_attention_heads ,				encoder_ffn_dim=self.intermediate_size ,				decoder_ffn_dim=self.intermediate_size ,				dropout=self.hidden_dropout_prob ,				attention_dropout=self.attention_probs_dropout_prob ,				max_position_embeddings=self.max_position_embeddings ,				eos_token_ids=[2] ,				bos_token_id=self.bos_token_id ,				pad_token_id=self.pad_token_id ,				decoder_start_token_id=self.pad_token_id ,				attention_window=self.attention_window ,				**self.config_updates ,				)
													__SCREAMING_SNAKE_CASE										=   prepare_led_inputs_dict(_UpperCamelCase ,				_UpperCamelCase ,				_UpperCamelCase						)
													__SCREAMING_SNAKE_CASE										=   tf.concat(
													    [tf.zeros_like(_UpperCamelCase						)[:, :-1], tf.ones_like(_UpperCamelCase						)[:, -1:]] ,				axis=-1 ,				)
													__SCREAMING_SNAKE_CASE										=   global_attention_mask
													return config, inputs_dict






						def 			_A      (       self ,				_A ,				_A						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   TFLEDModel(config=_UpperCamelCase						).get_decoder()
													__SCREAMING_SNAKE_CASE										=   inputs_dict['input_ids']

													__SCREAMING_SNAKE_CASE										=   input_ids[:1, :]
													__SCREAMING_SNAKE_CASE										=   inputs_dict['attention_mask'][:1, :]
													__SCREAMING_SNAKE_CASE										=   1

													# first forward pass
													__SCREAMING_SNAKE_CASE										=   model(_UpperCamelCase ,				attention_mask=_UpperCamelCase ,				use_cache=_UpperCamelCase						)

													__SCREAMING_SNAKE_CASE				,			__SCREAMING_SNAKE_CASE										=   outputs.to_tuple()

													# create hypothetical next token and extent to next_input_ids
													__SCREAMING_SNAKE_CASE										=   ids_tensor((self.batch_size, 3) ,				config.vocab_size						)
													__SCREAMING_SNAKE_CASE										=   tf.cast(ids_tensor((self.batch_size, 3) ,				2						) ,				tf.inta						)

													# append to next input_ids and
													__SCREAMING_SNAKE_CASE										=   tf.concat([input_ids, next_tokens] ,				axis=-1						)
													__SCREAMING_SNAKE_CASE										=   tf.concat([attention_mask, next_attn_mask] ,				axis=-1						)

													__SCREAMING_SNAKE_CASE										=   model(_UpperCamelCase ,				attention_mask=_UpperCamelCase						)[0]
													__SCREAMING_SNAKE_CASE										=   model(_UpperCamelCase ,				attention_mask=_UpperCamelCase ,				past_key_values=_UpperCamelCase						)[0]

													self.parent.assertEqual(next_tokens.shape[1] ,				output_from_past.shape[1]						)

													# select random slice
													__SCREAMING_SNAKE_CASE										=   int(ids_tensor((1,) ,				output_from_past.shape[-1]						)						)
													__SCREAMING_SNAKE_CASE										=   output_from_no_past[:, -3:, random_slice_idx]
													__SCREAMING_SNAKE_CASE										=   output_from_past[:, :, random_slice_idx]

													# test that outputs are equal for slice
													tf.debugging.assert_near(_UpperCamelCase ,				_UpperCamelCase ,				rtol=1e-3						)







def       __lowercase  (					a__				,  a__				,  a__				,  a__=None				,  a__=None				,  a__=None				,  a__=None				,  )							->					Tuple:


							if attention_mask is None:
														__SCREAMING_SNAKE_CASE										=   tf.cast(tf.math.not_equal(__lowerCAmelCase				,  config.pad_token_id  )				,  tf.inta  )
							if decoder_attention_mask is None:
														__SCREAMING_SNAKE_CASE										=   tf.concat(
														    [
														        tf.ones(decoder_input_ids[:, :1].shape				,  dtype=tf.inta  ),
														        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]				,  config.pad_token_id  )				,  tf.inta  ),
														    ]				,  axis=-1				,  )
							if head_mask is None:
														__SCREAMING_SNAKE_CASE										=   tf.ones((config.encoder_layers, config.encoder_attention_heads)  )
							if decoder_head_mask is None:
														__SCREAMING_SNAKE_CASE										=   tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
							return {
							    "input_ids": input_ids,
							    "attention_mask": attention_mask,
							    "decoder_input_ids": decoder_input_ids,
							    "decoder_attention_mask": decoder_attention_mask,
							    "head_mask": head_mask,
							    "decoder_head_mask": decoder_head_mask,
							}

@require_tf
class   UpperCAmelCase_    (  __a       ,       __a       ,       unittest.TestCase			):

						'''simple docstring'''




						UpperCamelCase__     :					Any							    =    (TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
						UpperCamelCase__     :					str							    =    (TFLEDForConditionalGeneration,) if is_tf_available() else ()
						UpperCamelCase__     :					Tuple							    =    (
						    {
						        '''conversational''': TFLEDForConditionalGeneration,
						        '''feature-extraction''': TFLEDModel,
						        '''summarization''': TFLEDForConditionalGeneration,
						        '''text2text-generation''': TFLEDForConditionalGeneration,
						        '''translation''': TFLEDForConditionalGeneration,
						    }
						    if is_tf_available()
						    else {}
						)
						UpperCamelCase__     :					Any							    =    True
						UpperCamelCase__     :					str							    =    False
						UpperCamelCase__     :					Dict							    =    False
						UpperCamelCase__     :					Any							    =    False






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   TFLEDModelTester(self						)
													__SCREAMING_SNAKE_CASE										=   ConfigTester(self ,				config_class=_UpperCamelCase						)






						def 			_A      (       self						):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs_for_common()
													self.model_tester.check_decoder_model_past_large_inputs(*_UpperCamelCase						)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE				,			__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs_for_common()
													__SCREAMING_SNAKE_CASE										=   tf.zeros_like(inputs_dict['attention_mask']						)
													__SCREAMING_SNAKE_CASE										=   2
													__SCREAMING_SNAKE_CASE										=   tf.where(
													    tf.range(self.model_tester.seq_length						)[None, :] < num_global_attn_indices ,				1 ,				inputs_dict['global_attention_mask'] ,				)

													__SCREAMING_SNAKE_CASE										=   True
													__SCREAMING_SNAKE_CASE										=   self.model_tester.seq_length
													__SCREAMING_SNAKE_CASE										=   self.model_tester.encoder_seq_length

													def check_decoder_attentions_output(_A						):
																				__SCREAMING_SNAKE_CASE										=   outputs.decoder_attentions
																				self.assertEqual(len(_UpperCamelCase						) ,				self.model_tester.num_hidden_layers						)
																				self.assertListEqual(
																				    list(decoder_attentions[0].shape[-3:]						) ,				[self.model_tester.num_attention_heads, seq_length, seq_length] ,				)

													def check_encoder_attentions_output(_A						):
																				__SCREAMING_SNAKE_CASE										=   [t.numpy() for t in outputs.encoder_attentions]
																				__SCREAMING_SNAKE_CASE										=   [t.numpy() for t in outputs.encoder_global_attentions]
																				self.assertEqual(len(_UpperCamelCase						) ,				self.model_tester.num_hidden_layers						)
																				self.assertEqual(len(_UpperCamelCase						) ,				self.model_tester.num_hidden_layers						)
																				self.assertListEqual(
																				    list(attentions[0].shape[-3:]						) ,				[self.model_tester.num_attention_heads, seq_length, seq_length] ,				)
																				self.assertListEqual(
																				    list(global_attentions[0].shape[-3:]						) ,				[self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices] ,				)

													for model_class in self.all_model_classes:
																				__SCREAMING_SNAKE_CASE										=   True
																				__SCREAMING_SNAKE_CASE										=   False
																				__SCREAMING_SNAKE_CASE										=   False
																				__SCREAMING_SNAKE_CASE										=   model_class(_UpperCamelCase						)
																				__SCREAMING_SNAKE_CASE										=   model(self._prepare_for_class(_UpperCamelCase ,				_UpperCamelCase						)						)
																				__SCREAMING_SNAKE_CASE										=   len(_UpperCamelCase						)
																				self.assertEqual(config.output_hidden_states ,				_UpperCamelCase						)
																				check_encoder_attentions_output(_UpperCamelCase						)

																				if self.is_encoder_decoder:
																											__SCREAMING_SNAKE_CASE										=   model_class(_UpperCamelCase						)
																											__SCREAMING_SNAKE_CASE										=   model(self._prepare_for_class(_UpperCamelCase ,				_UpperCamelCase						)						)
																											self.assertEqual(config.output_hidden_states ,				_UpperCamelCase						)
																											check_decoder_attentions_output(_UpperCamelCase						)

																				# Check that output attentions can also be changed via the config
																				del inputs_dict["output_attentions"]
																				__SCREAMING_SNAKE_CASE										=   True
																				__SCREAMING_SNAKE_CASE										=   model_class(_UpperCamelCase						)
																				__SCREAMING_SNAKE_CASE										=   model(self._prepare_for_class(_UpperCamelCase ,				_UpperCamelCase						)						)
																				self.assertEqual(config.output_hidden_states ,				_UpperCamelCase						)
																				check_encoder_attentions_output(_UpperCamelCase						)

																				# Check attention is always last and order is fine
																				__SCREAMING_SNAKE_CASE										=   True
																				__SCREAMING_SNAKE_CASE										=   True
																				__SCREAMING_SNAKE_CASE										=   model_class(_UpperCamelCase						)
																				__SCREAMING_SNAKE_CASE										=   model(self._prepare_for_class(_UpperCamelCase ,				_UpperCamelCase						)						)

																				self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1) ,				len(_UpperCamelCase						)						)
																				self.assertEqual(model.config.output_hidden_states ,				_UpperCamelCase						)
																				check_encoder_attentions_output(_UpperCamelCase						)






						@unittest.skip('LED keeps using potentially symbolic tensors in conditionals and breaks tracing.'						)
						def 			_A      (       self						):







													'''simple docstring'''

													pass






						def 			_A      (       self						):







													'''simple docstring'''

													pass







def       __lowercase  (					a__  )							->					int:
							return tf.constant(__lowerCAmelCase				,  dtype=tf.intaa  )


lowerCAmelCase__						:	Any					=1E-4

@slow
@require_tf
class   UpperCAmelCase_    (  unittest.TestCase			):

						'''simple docstring'''




						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   TFLEDForConditionalGeneration.from_pretrained('allenai/led-base-16384'						).led

													# change to intended input here
													__SCREAMING_SNAKE_CASE										=   _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]						)
													__SCREAMING_SNAKE_CASE										=   _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]						)
													__SCREAMING_SNAKE_CASE										=   prepare_led_inputs_dict(model.config ,				_UpperCamelCase ,				_UpperCamelCase						)
													__SCREAMING_SNAKE_CASE										=   model(**_UpperCamelCase						)[0]
													__SCREAMING_SNAKE_CASE										=   (1, 1_024, 768)
													self.assertEqual(output.shape ,				_UpperCamelCase						)
													# change to expected output here
													__SCREAMING_SNAKE_CASE										=   tf.convert_to_tensor(
													    [[2.3_0_5_0, 2.8_2_7_9, 0.6_5_3_1], [-1.8_4_5_7, -0.1_4_5_5, -3.5_6_6_1], [-1.0_1_8_6, 0.4_5_8_6, -2.2_0_4_3]] ,				)
													tf.debugging.assert_near(output[:, :3, :3] ,				_UpperCamelCase ,				atol=1e-3						)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   TFLEDForConditionalGeneration.from_pretrained('allenai/led-base-16384'						)

													# change to intended input here
													__SCREAMING_SNAKE_CASE										=   _long_tensor([512 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]						)
													__SCREAMING_SNAKE_CASE										=   _long_tensor([128 * [0, 31_414, 232, 328, 740, 1_140, 12_695, 69]]						)
													__SCREAMING_SNAKE_CASE										=   prepare_led_inputs_dict(model.config ,				_UpperCamelCase ,				_UpperCamelCase						)
													__SCREAMING_SNAKE_CASE										=   model(**_UpperCamelCase						)[0]
													__SCREAMING_SNAKE_CASE										=   (1, 1_024, model.config.vocab_size)
													self.assertEqual(output.shape ,				_UpperCamelCase						)
													# change to expected output here
													__SCREAMING_SNAKE_CASE										=   tf.convert_to_tensor(
													    [[3_3.6_5_0_7, 6.4_5_7_2, 1_6.8_0_8_9], [5.8_7_3_9, -2.4_2_3_8, 1_1.2_9_0_2], [-3.2_1_3_9, -4.3_1_4_9, 4.2_7_8_3]] ,				)
													tf.debugging.assert_near(output[:, :3, :3] ,				_UpperCamelCase ,				atol=1e-3 ,				rtol=1e-3						)








import argparse
import struct
import unittest





class       _lowerCAmelCase   :




				def __init__(   self							,							_UpperCamelCase	)							-> None:
							lowerCAmelCase_         =      data

							# Initialize hash values
							lowerCAmelCase_         =      [
							    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
							lowerCAmelCase_         =      [
							    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,
							]

							lowerCAmelCase_         =      self.preprocessing(self.data	)
							self.final_hash()




				@staticmethod
				def 	__a		(   _UpperCamelCase	)							-> bytes:
							lowerCAmelCase_         =      B"\x80" + (B"\x00" * (63 - (len(_UpperCamelCase	) + 8) % 64))
							lowerCAmelCase_         =      struct.pack(">Q"							,							(len(_UpperCamelCase	) * 8)	)
							return data + padding + big_endian_integer




				def 	__a		(   self	)							-> None:
							# 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"							,							_UpperCamelCase	)	)
										# 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
																) % 0x1_0_0_0_0_0_0_0_0

													# Compression
													lowerCAmelCase_         =      self.ror(_UpperCamelCase							,							6	) ^ self.ror(_UpperCamelCase							,							11	) ^ self.ror(_UpperCamelCase							,							25	)
													lowerCAmelCase_         =      (e & f) ^ ((~e & 0xF_F_F_F_F_F_F_F) & g)
													lowerCAmelCase_         =      (
													    h + sa + ch + self.round_constants[index] + words[index]
													) % 0x1_0_0_0_0_0_0_0_0
													lowerCAmelCase_         =      self.ror(_UpperCamelCase							,							2	) ^ self.ror(_UpperCamelCase							,							13	) ^ self.ror(_UpperCamelCase							,							22	)
													lowerCAmelCase_         =      (a & b) ^ (a & c) ^ (b & c)
													lowerCAmelCase_         =      (sa + maj) % 0x1_0_0_0_0_0_0_0_0

													lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_         =      (
													    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),
													)

										lowerCAmelCase_         =      [a, b, c, d, e, f, g, h]

										# Modify final values
										lowerCAmelCase_         =      [
										    ((element + mutated_hash_values[index]) % 0x1_0_0_0_0_0_0_0_0)
										    for index, element in enumerate(self.hashes	)
										]

							lowerCAmelCase_         =      "".join([hex(_UpperCamelCase	)[2:].zfill(8	) for value in self.hashes]	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase	)							-> int:
							return 0xF_F_F_F_F_F_F_F & (value << (32 - rotations)) | (value >> rotations)





class       _lowerCAmelCase   (      unittest.TestCase			):




				def 	__a		(   self	)							-> None:
							import hashlib

							lowerCAmelCase_         =      bytes("Test String"							,							"utf-8"	)
							self.assertEqual(SHAaaa(_UpperCamelCase	).hash							,							hashlib.shaaaa(_UpperCamelCase	).hexdigest()	)






def   lowerCamelCase__							(							):




			"""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()



