
"""simple docstring"""






import argparse
import struct
import unittest

class 					__a     :



							'''simple docstring'''







							def __init__(     self  ,    _lowerCamelCase       )			->							None:




										'''simple docstring'''
										__lowercase       =       data

										# Initialize hash values
										__lowercase       =       [
										    0X6a09e667,
										    0Xbb67ae85,
										    0X3c6ef372,
										    0Xa54ff53a,
										    0X510e527f,
										    0X9b05688c,
										    0X1f83d9ab,
										    0X5be0cd19,
										]

										# Initialize round constants
										__lowercase       =       [
										    0X428a2f98,
										    0X71374491,
										    0Xb5c0fbcf,
										    0Xe9b5dba5,
										    0X3956c25b,
										    0X59f111f1,
										    0X923f82a4,
										    0Xab1c5ed5,
										    0Xd807aa98,
										    0X12835b01,
										    0X243185be,
										    0X550c7dc3,
										    0X72be5d74,
										    0X80deb1fe,
										    0X9bdc06a7,
										    0Xc19bf174,
										    0Xe49b69c1,
										    0Xefbe4786,
										    0X0fc19dc6,
										    0X240ca1cc,
										    0X2de92c6f,
										    0X4a7484aa,
										    0X5cb0a9dc,
										    0X76f988da,
										    0X983e5152,
										    0Xa831c66d,
										    0Xb00327c8,
										    0Xbf597fc7,
										    0Xc6e00bf3,
										    0Xd5a79147,
										    0X06ca6351,
										    0X14292967,
										    0X27b70a85,
										    0X2e1b2138,
										    0X4d2c6dfc,
										    0X53380d13,
										    0X650a7354,
										    0X766a0abb,
										    0X81c2c92e,
										    0X92722c85,
										    0Xa2bfe8a1,
										    0Xa81a664b,
										    0Xc24b8b70,
										    0Xc76c51a3,
										    0Xd192e819,
										    0Xd6990624,
										    0Xf40e3585,
										    0X106aa070,
										    0X19a4c116,
										    0X1e376c08,
										    0X2748774c,
										    0X34b0bcb5,
										    0X391c0cb3,
										    0X4ed8aa4a,
										    0X5b9cca4f,
										    0X682e6ff3,
										    0X748f82ee,
										    0X78a5636f,
										    0X84c87814,
										    0X8cc70208,
										    0X90befffa,
										    0Xa4506ceb,
										    0Xbef9a3f7,
										    0Xc67178f2,
										]

										__lowercase       =       self.preprocessing(self.data       )
										self.final_hash()
							@staticmethod
							def   SCREAMING_SNAKE_CASE						(     _lowerCamelCase       )			->							bytes:




										'''simple docstring'''
										__lowercase       =       b"\x80" + (b"\x00" * (63 - (len(_lowerCamelCase       ) + 8) % 64))
										__lowercase       =       struct.pack(">Q"  ,    (len(_lowerCamelCase       ) * 8)       )
										return data + padding + big_endian_integer
							def   SCREAMING_SNAKE_CASE						(     self       )			->							None:




										'''simple docstring'''
										# Convert into blocks of 64 bytes
										__lowercase       =       [
										    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
													__lowercase       =       list(struct.unpack(">16L"  ,    _lowerCamelCase       )       )
													# add 48 0-ed integers
													words += [0] * 48

													__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase       =       self.hashes

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

																			__lowercase       =       (
																			    words[index - 16] + sa + words[index - 7] + sa
																			) % 0X100000000

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

																__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase       =       (
																    g,
																    f,
																    e,
																    ((d + tempa) % 0X100000000),
																    c,
																    b,
																    a,
																    ((tempa + tempa) % 0X100000000),
																)

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

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

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





							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							int:




										'''simple docstring'''
										return 0Xffffffff & (value << (32 - rotations)) | (value >> rotations)





class 					__a     ( unittest.TestCase       ):



							'''simple docstring'''







							def   SCREAMING_SNAKE_CASE						(     self       )			->							None:




										'''simple docstring'''
										import hashlib

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





def      lowerCAmelCase__			(		)						->None:
			import doctest

			doctest.testmod()

			__lowercase       =       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"      )

			__lowercase       =       parser.parse_args()

			__lowercase       =       args.input_string

			# hash input should be a bytestring
			if args.input_file:
						with open(args.input_file			,   "rb"      ) as f:
									__lowercase       =       f.read()
			else:
						__lowercase       =       bytes(__magic_name__			,   "utf-8"      )

			print(SHAaaa(__magic_name__      ).hash      )


if __name__ == "__main__":
					main()







"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_lowercase							=				{
    '''configuration_mask2former''': [
        '''MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Mask2FormerConfig''',
    ],
}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowercase							=				['''Mask2FormerImageProcessor''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_lowercase							=				[
					    '''MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''Mask2FormerForUniversalSegmentation''',
					    '''Mask2FormerModel''',
					    '''Mask2FormerPreTrainedModel''',
					]

if TYPE_CHECKING:
					from .configuration_maskaformer import MASK2FORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, MaskaFormerConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .image_processing_maskaformer import MaskaFormerImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_maskaformer import (
										    MASK2FORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    MaskaFormerForUniversalSegmentation,
										    MaskaFormerModel,
										    MaskaFormerPreTrainedModel,
										)


else:
					import sys

					_lowercase							=				_LazyModule(__name__, globals()['''__file__'''], _import_structure)





