





"""simple docstring"""






import argparse
import struct
import unittest




class 			__lowercase     :







     '''simple docstring'''




     def __init__(  self		,     _UpperCAmelCase       ):
         __a	:  Union[str, Any]         =					data

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

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

         __a	:  Any         =					self.preprocessing(self.data       )
         self.final_hash()







     @staticmethod
     def 	_lowerCamelCase						(  _UpperCAmelCase       ):
         __a	:  str         =					b'''\x80''' + (b'''\x00''' * (63 - (len(__lowerCAmelCase       ) + 8) % 64))
         __a	:  int         =					struct.pack('''>Q'''		,     (len(__lowerCAmelCase       ) * 8)       )
         return data + padding + big_endian_integer







     def 	_lowerCamelCase						(  self       ):
         __a	:  Optional[int]         =					[
             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	:  int         =					list(struct.unpack('''>16L'''		,     __lowerCAmelCase       )       )
             # add 48 0-ed integers
             words += [0] * 48

             __a    ,  __a    ,  __a    ,  __a    ,  __a    ,  __a    ,  __a    ,  __a	:  Optional[int]         =					self.hashes

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

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

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

                 __a    ,  __a    ,  __a    ,  __a    ,  __a    ,  __a    ,  __a    ,  __a	:  int         =					(
                     g,
                     f,
                     e,
                     ((d + tempa) % 0x1_0000_0000),
                     c,
                     b,
                     a,
                     ((tempa + tempa) % 0x1_0000_0000),
                 )

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

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

         __a	:  Any         =					''''''.join([hex(__lowerCAmelCase       )[2:].zfill(8       ) for value in self.hashes]       )







     def 	_lowerCamelCase						(  self		,     _UpperCAmelCase		,     _UpperCAmelCase       ):
         return 0xffff_ffff & (value << (32 - rotations)) | (value >> rotations)






class 			__lowercase     (     unittest.TestCase							):







     '''simple docstring'''




     def 	_lowerCamelCase						(  self       ):
         import hashlib

         __a	:  Optional[Any]         =					bytes('''Test String'''		,     '''utf-8'''       )
         self.assertEqual(SHAaaa(__lowerCAmelCase       ).hash		,     hashlib.shaaaa(__lowerCAmelCase       ).hexdigest()       )






def       __A (     )						->						None:
    import doctest

    doctest.testmod()

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

    __a	:  Dict         =					parser.parse_args()

    __a	:  Optional[Any]         =					args.input_string

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

    print(SHAaaa(lowerCAmelCase__).hash)


if __name__ == "__main__":
  main()






"""simple docstring"""






def       __A (     a_  :int = 1_00_00_00)						->						int:
				__a	:  Tuple         =					[i - 1 for i in range(limit + 1)]

				for i in range(2				,    limit + 1):
								if phi[i] == i - 1:
												for j in range(2 * i				,    limit + 1				,    a_):
																phi[j] -= phi[j] // i

				return sum(phi[2 : limit + 1])


if __name__ == "__main__":
		print(solution())