import argparse
import struct
import unittest




class 	__snake_case	:





      '''simple docstring'''






      def __init__(					self     :				List[Any]    ,  _UpperCamelCase     :				bytes)				->None:


          """simple docstring"""


          _lowerCamelCase     :		str 						=						data

          # Initialize hash values
          _lowerCamelCase     :		Any 						=						[
              0x6a09_e667,
              0xbb67_ae85,
              0x3c6e_f372,
              0xa54f_f53a,
              0x510e_527f,
              0x9b05_688c,
              0x1f83_d9ab,
              0x5be0_cd19,
          ]

          # Initialize round constants
          _lowerCamelCase     :		int 						=						[
              0x428a_2f98,
              0x7137_4491,
              0xb5c0_fbcf,
              0xe9b5_dba5,
              0x3956_c25b,
              0x59f1_11f1,
              0x923f_82a4,
              0xab1c_5ed5,
              0xd807_aa98,
              0x1283_5b01,
              0x2431_85be,
              0x550c_7dc3,
              0x72be_5d74,
              0x80de_b1fe,
              0x9bdc_06a7,
              0xc19b_f174,
              0xe49b_69c1,
              0xefbe_4786,
              0x0fc1_9dc6,
              0x240c_a1cc,
              0x2de9_2c6f,
              0x4a74_84aa,
              0x5cb0_a9dc,
              0x76f9_88da,
              0x983e_5152,
              0xa831_c66d,
              0xb003_27c8,
              0xbf59_7fc7,
              0xc6e0_0bf3,
              0xd5a7_9147,
              0x06ca_6351,
              0x1429_2967,
              0x27b7_0a85,
              0x2e1b_2138,
              0x4d2c_6dfc,
              0x5338_0d13,
              0x650a_7354,
              0x766a_0abb,
              0x81c2_c92e,
              0x9272_2c85,
              0xa2bf_e8a1,
              0xa81a_664b,
              0xc24b_8b70,
              0xc76c_51a3,
              0xd192_e819,
              0xd699_0624,
              0xf40e_3585,
              0x106a_a070,
              0x19a4_c116,
              0x1e37_6c08,
              0x2748_774c,
              0x34b0_bcb5,
              0x391c_0cb3,
              0x4ed8_aa4a,
              0x5b9c_ca4f,
              0x682e_6ff3,
              0x748f_82ee,
              0x78a5_636f,
              0x84c8_7814,
              0x8cc7_0208,
              0x90be_fffa,
              0xa450_6ceb,
              0xbef9_a3f7,
              0xc671_78f2,
          ]

          _lowerCamelCase     :		Union[str, Any] 						=						self.preprocessing(self.data)
          self.final_hash()



      @staticmethod
      def 	_SCREAMING_SNAKE_CASE    (					_UpperCamelCase     :				bytes)				->bytes:


          """simple docstring"""


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



      def 	_SCREAMING_SNAKE_CASE    (					self     :				Optional[Any])				->None:


          """simple docstring"""


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

              _lowerCamelCase     :		Optional[int] 						=						self.hashes

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

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

                  # Compression
                  _lowerCamelCase     :		Optional[int] 						=						self.ror(_UpperCamelCase    ,  6) ^ self.ror(_UpperCamelCase    ,  11) ^ self.ror(_UpperCamelCase    ,  25)
                  _lowerCamelCase     :		str 						=						(e & f) ^ ((~e & 0xffff_ffff) & g)
                  _lowerCamelCase     :		Union[str, Any] 						=						(
                      h + sa + ch + self.round_constants[index] + words[index]
                  ) % 0x1_0000_0000
                  _lowerCamelCase     :		List[str] 						=						self.ror(_UpperCamelCase    ,  2) ^ self.ror(_UpperCamelCase    ,  13) ^ self.ror(_UpperCamelCase    ,  22)
                  _lowerCamelCase     :		List[str] 						=						(a & b) ^ (a & c) ^ (b & c)
                  _lowerCamelCase     :		Dict 						=						(sa + maj) % 0x1_0000_0000

                  _lowerCamelCase     :		List[str] 						=						(
                      g,
                      f,
                      e,
                      ((d + tempa) % 0x1_0000_0000),
                      c,
                      b,
                      a,
                      ((tempa + tempa) % 0x1_0000_0000),
                  )

              _lowerCamelCase     :		List[Any] 						=						[a, b, c, d, e, f, g, h]

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

          _lowerCamelCase     :		Union[str, Any] 						=						"""""".join([hex(_UpperCamelCase)[2:].zfill(8) for value in self.hashes])




      def 	_SCREAMING_SNAKE_CASE    (					self     :				Dict    ,  _UpperCamelCase     :				int    ,  _UpperCamelCase     :				int)				->int:


          """simple docstring"""


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





class 	__snake_case	( unittest.TestCase		):





      '''simple docstring'''






      def 	_SCREAMING_SNAKE_CASE    (					self     :				Optional[Any])				->None:


          """simple docstring"""


          import hashlib

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







def 						A__  (					):







    '''simple docstring'''
    import doctest

    doctest.testmod()

    _lowerCamelCase     :		Union[str, 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"""	)

    _lowerCamelCase     :		Optional[Any] 						=						parser.parse_args()

    _lowerCamelCase     :		Union[str, Any] 						=						args.input_string

    # hash input should be a bytestring
    if args.input_file:
        with open(args.input_file   , """rb"""	) as f:
            _lowerCamelCase     :		Tuple 						=						f.read()
    else:
        _lowerCamelCase     :		List[Any] 						=						bytes(__A   , """utf-8"""	)

    print(SHAaaa(__A	).hash	)


if __name__ == "__main__":
    main()





import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp







def 						A__  (					):







    '''simple docstring'''
    _lowerCamelCase     :		Optional[int] 						=						ArgumentParser(
        description=(
            """PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"""
        )	)

    # Optional arguments for the launch helper
    parser.add_argument("""--num_cores"""   , type=__A   , default=1   , help="""Number of TPU cores to use (1 or 8)."""	)

    # positional
    parser.add_argument(
        """training_script"""   , type=__A   , help=(
            """The full path to the single TPU training """
            """program/script to be launched in parallel, """
            """followed by all the arguments for the """
            """training script"""
        )   , )

    # rest from the training program
    parser.add_argument("""training_script_args"""   , nargs=__A	)

    return parser.parse_args()







def 						A__  (					):







    '''simple docstring'''
    _lowerCamelCase     :		List[str] 						=						parse_args()

    # Import training_script as a module.
    _lowerCamelCase     :		List[Any] 						=						Path(args.training_script	)
    sys.path.append(str(script_fpath.parent.resolve()	)	)
    _lowerCamelCase     :		Optional[Any] 						=						script_fpath.stem
    _lowerCamelCase     :		Dict 						=						importlib.import_module(__A	)

    # Patch sys.argv
    _lowerCamelCase     :		Union[str, Any] 						=						[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores	)]

    xmp.spawn(mod._mp_fn   , args=()   , nprocs=args.num_cores	)


if __name__ == "__main__":
    main()




