





'''simple docstring'''


import argparse
import struct
import unittest

class    lowerCAmelCase_		:




 def __init__(	self			,     _lowerCAmelCase		)    ->							Any:
     _lowerCAmelCase				=				data

     # Initialize hash values
     _lowerCAmelCase				=				[
         0X6A_09_E6_67,
         0XBB_67_AE_85,
         0X3C_6E_F3_72,
         0XA5_4F_F5_3A,
         0X51_0E_52_7F,
         0X9B_05_68_8C,
         0X1F_83_D9_AB,
         0X5B_E0_CD_19,
     ]

     # Initialize round constants
     _lowerCAmelCase				=				[
         0X42_8A_2F_98,
         0X71_37_44_91,
         0XB5_C0_FB_CF,
         0XE9_B5_DB_A5,
         0X39_56_C2_5B,
         0X59_F1_11_F1,
         0X92_3F_82_A4,
         0XAB_1C_5E_D5,
         0XD8_07_AA_98,
         0X12_83_5B_01,
         0X24_31_85_BE,
         0X55_0C_7D_C3,
         0X72_BE_5D_74,
         0X80_DE_B1_FE,
         0X9B_DC_06_A7,
         0XC1_9B_F1_74,
         0XE4_9B_69_C1,
         0XEF_BE_47_86,
         0X0F_C1_9D_C6,
         0X24_0C_A1_CC,
         0X2D_E9_2C_6F,
         0X4A_74_84_AA,
         0X5C_B0_A9_DC,
         0X76_F9_88_DA,
         0X98_3E_51_52,
         0XA8_31_C6_6D,
         0XB0_03_27_C8,
         0XBF_59_7F_C7,
         0XC6_E0_0B_F3,
         0XD5_A7_91_47,
         0X06_CA_63_51,
         0X14_29_29_67,
         0X27_B7_0A_85,
         0X2E_1B_21_38,
         0X4D_2C_6D_FC,
         0X53_38_0D_13,
         0X65_0A_73_54,
         0X76_6A_0A_BB,
         0X81_C2_C9_2E,
         0X92_72_2C_85,
         0XA2_BF_E8_A1,
         0XA8_1A_66_4B,
         0XC2_4B_8B_70,
         0XC7_6C_51_A3,
         0XD1_92_E8_19,
         0XD6_99_06_24,
         0XF4_0E_35_85,
         0X10_6A_A0_70,
         0X19_A4_C1_16,
         0X1E_37_6C_08,
         0X27_48_77_4C,
         0X34_B0_BC_B5,
         0X39_1C_0C_B3,
         0X4E_D8_AA_4A,
         0X5B_9C_CA_4F,
         0X68_2E_6F_F3,
         0X74_8F_82_EE,
         0X78_A5_63_6F,
         0X84_C8_78_14,
         0X8C_C7_02_08,
         0X90_BE_FF_FA,
         0XA4_50_6C_EB,
         0XBE_F9_A3_F7,
         0XC6_71_78_F2,
     ]

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




 @staticmethod
 def 							_snake_case   (	_lowerCAmelCase		)    ->							Optional[int]:
     _lowerCAmelCase				=				B"\x80" + (B"\x00" * (63 - (len(_lowerCAmelCase		) + 8) % 64))
     _lowerCAmelCase				=				struct.pack(">Q"			,     (len(_lowerCAmelCase		) * 8)		)
     return data + padding + big_endian_integer




 def 							_snake_case   (	self		)    ->							str:
     # 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"			,     _lowerCAmelCase		)		)
         # 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_00_00_00_00

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

             _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=				(
                 g,
                 f,
                 e,
                 ((d + tempa) % 0X1_00_00_00_00),
                 c,
                 b,
                 a,
                 ((tempa + tempa) % 0X1_00_00_00_00),
             )

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

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

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





 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase		)    ->							Dict:
     return 0XFF_FF_FF_FF & (value << (32 - rotations)) | (value >> rotations)







class    lowerCAmelCase_		(		unittest.TestCase		):




 def 							_snake_case   (	self		)    ->							Tuple:
     import hashlib

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







def 	__a():



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









'''simple docstring'''


def 	__a(SCREAMING_SNAKE_CASE_  :					int    ):



    '''simple docstring'''





    if not isinstance(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    ):
        raise ValueError("check_bouncy() accepts only integer arguments"    )
    _lowerCAmelCase				=      str(SCREAMING_SNAKE_CASE_    )
    _lowerCAmelCase				=      "".join(sorted(SCREAMING_SNAKE_CASE_    )    )
    return sorted_str_n != str_n and sorted_str_n[::-1] != str_n


def 	__a(SCREAMING_SNAKE_CASE_  :					float = 99    ):



    '''simple docstring'''





    if not 0 < percent < 100:
        raise ValueError("solution() only accepts values from 0 to 100"    )
    _lowerCAmelCase				=      0
    _lowerCAmelCase				=      1

    while True:
        if check_bouncy(SCREAMING_SNAKE_CASE_    ):
            bouncy_num += 1
        if (bouncy_num / num) * 100 >= percent:
            return num
        num += 1


if __name__ == "__main__":
       from doctest import testmod

       testmod()
       print(f'''{solution(99)}''')


