
import argparse
import struct
import unittest




class     _SCREAMING_SNAKE_CASE     :



	def __init__(    self						,  lowercase )				->       None:
					lowerCamelCase_						=			data

					# Initialize hash values
					lowerCamelCase_						=			[
					    0x6a_09e_667,
					    0xbb_67a_e85,
					    0x3c_6ef_372,
					    0xa5_4ff_53a,
					    0x51_0e5_27f,
					    0x9b_056_88c,
					    0x1f_83d_9ab,
					    0x5b_e0c_d19,
					]

					# Initialize round constants
					lowerCamelCase_						=			[
					    0x42_8a2_f98,
					    0x71_374_491,
					    0xb5_c0f_bcf,
					    0xe9_b5d_ba5,
					    0x39_56c_25b,
					    0x59_f11_1f1,
					    0x92_3f8_2a4,
					    0xab_1c5_ed5,
					    0xd8_07a_a98,
					    0x12_835_b01,
					    0x24_318_5be,
					    0x55_0c7_dc3,
					    0x72_be5_d74,
					    0x80_deb_1fe,
					    0x9b_dc0_6a7,
					    0xc1_9bf_174,
					    0xe4_9b6_9c1,
					    0xef_be4_786,
					    0x0f_c19_dc6,
					    0x24_0ca_1cc,
					    0x2d_e92_c6f,
					    0x4a_748_4aa,
					    0x5c_b0a_9dc,
					    0x76_f98_8da,
					    0x98_3e5_152,
					    0xa8_31c_66d,
					    0xb0_032_7c8,
					    0xbf_597_fc7,
					    0xc6_e00_bf3,
					    0xd5_a79_147,
					    0x06_ca6_351,
					    0x14_292_967,
					    0x27_b70_a85,
					    0x2e_1b2_138,
					    0x4d_2c6_dfc,
					    0x53_380_d13,
					    0x65_0a7_354,
					    0x76_6a0_abb,
					    0x81_c2c_92e,
					    0x92_722_c85,
					    0xa2_bfe_8a1,
					    0xa8_1a6_64b,
					    0xc2_4b8_b70,
					    0xc7_6c5_1a3,
					    0xd1_92e_819,
					    0xd6_990_624,
					    0xf4_0e3_585,
					    0x10_6aa_070,
					    0x19_a4c_116,
					    0x1e_376_c08,
					    0x27_487_74c,
					    0x34_b0b_cb5,
					    0x39_1c0_cb3,
					    0x4e_d8a_a4a,
					    0x5b_9cc_a4f,
					    0x68_2e6_ff3,
					    0x74_8f8_2ee,
					    0x78_a56_36f,
					    0x84_c87_814,
					    0x8c_c70_208,
					    0x90_bef_ffa,
					    0xa4_506_ceb,
					    0xbe_f9a_3f7,
					    0xc6_717_8f2,
					]

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



	@staticmethod
	def     SCREAMING_SNAKE_CASE_(    lowercase )				->       bytes:
					lowerCamelCase_						=			b"\x80" + (b"\x00" * (63 - (len(lowercase ) + 8) % 64))
					lowerCamelCase_						=			struct.pack(">Q"						,  (len(lowercase ) * 8) )
					return data + padding + big_endian_integer



	def     SCREAMING_SNAKE_CASE_(    self )				->       None:
					# 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"						,  lowercase ) )
									# 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
																	) % 0x100_000_000

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

													lowerCamelCase_	,    lowerCamelCase_	,    lowerCamelCase_	,    lowerCamelCase_	,    lowerCamelCase_	,    lowerCamelCase_	,    lowerCamelCase_	,    lowerCamelCase_						=			(
													    g,
													    f,
													    e,
													    ((d + tempa) % 0x100_000_000),
													    c,
													    b,
													    a,
													    ((tempa + tempa) % 0x100_000_000),
													)

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

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

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



	def     SCREAMING_SNAKE_CASE_(    self						,  lowercase						,  lowercase )				->       int:
					return 0xff_fff_fff & (value << (32 - rotations)) | (value >> rotations)




class     _SCREAMING_SNAKE_CASE     (      unittest.TestCase						):



	def     SCREAMING_SNAKE_CASE_(    self )				->       None:
					import hashlib

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





def 			lowerCamelCase_ (				):
				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"""
from collections import defaultdict
from math import ceil, sqrt

def       _snake_case						(						UpperCamelCase						:		int = 1000000			,		UpperCamelCase						:		int = 10						):
 UpperCAmelCase	:					defaultdict	=	defaultdict(UpperCamelCase						)

 for outer_width in range(3			,		(t_limit // 4) + 2						):
  if outer_width * outer_width > t_limit:
   UpperCAmelCase	:					str	=	max(
       ceil(sqrt(outer_width * outer_width - t_limit						)						)			,		1						)
  else:
   UpperCAmelCase	:					Optional[Any]	=	1

  hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

  for hole_width in range(UpperCamelCase			,		outer_width - 1			,		2						):
   count[outer_width * outer_width - hole_width * hole_width] += 1

 return sum(1 for n in count.values() if 1 <= n <= 10						)


if __name__ == "__main__":
      print(f"""{solution() = }""")
