

"""simple docstring"""



import argparse
import struct
import unittest



class 					a						:



    """simple docstring"""



    def __init__(     self: Union[str, Any]    ,						UpperCamelCase: bytes       ):






         """simple docstring"""


         A__										=  data

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

         # Initialize round constants
         A__										=  [
             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,
         ]

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

    @staticmethod
    def 				UpperCamelCase	(     UpperCamelCase: bytes       ):






         """simple docstring"""


         A__										=  B"""\x80""" + (B"""\x00""" * (63 - (len(UpperCamelCase       ) + 8) % 64))
         A__										=  struct.pack(""">Q"""    ,						(len(UpperCamelCase       ) * 8)       )
         return data + padding + big_endian_integer

    def 				UpperCamelCase	(     self: Union[str, Any]       ):






         """simple docstring"""


         A__										=  [
             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
              A__										=  list(struct.unpack(""">16L"""    ,						UpperCamelCase       )       )
              # add 48 0-ed integers
              words += [0] * 48

              A__			,				A__			,				A__			,				A__			,				A__			,				A__			,				A__			,				A__										=  self.hashes

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

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

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

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

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

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

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





    def 				UpperCamelCase	(     self: Any    ,						UpperCamelCase: int    ,						UpperCamelCase: int       ):






         """simple docstring"""


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



class 					a						(       unittest.TestCase				):



    """simple docstring"""



    def 				UpperCamelCase	(     self: Any       ):






         """simple docstring"""


         import hashlib

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





def  _snake_case     (    ):
     import doctest

     doctest.testmod()

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

     A__										=  parser.parse_args()

     A__										=  args.input_string

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

     print(SHAaaa(lowerCamelCase__			).hash			)


if __name__ == "__main__":
       main()









"""simple docstring"""



SCREAMING_SNAKE_CASE_					:	str							  =						'0.21.0'

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
 from .utils import rich






