


'''simple docstring'''

import argparse
import struct
import unittest





class 	snake_case       :





  """simple docstring"""




  def __init__(       self     ,    UpperCamelCase	):







   """simple docstring"""
   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     snake_case						(       UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    b'''\x80''' + (b'''\x00''' * (63 - (len(SCREAMING_SNAKE_CASE__	) + 8) % 64))
   lowerCamelCase_						=    struct.pack(">Q"     ,    (len(SCREAMING_SNAKE_CASE__	) * 8)	)
   return data + padding + big_endian_integer






  def     snake_case						(       self	):







   """simple docstring"""
   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"     ,    SCREAMING_SNAKE_CASE__	)	)
    # add 48 0-ed integers
    words += [0] * 48

    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(SCREAMING_SNAKE_CASE__     ,    6	) ^ self.ror(SCREAMING_SNAKE_CASE__     ,    11	) ^ self.ror(SCREAMING_SNAKE_CASE__     ,    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(SCREAMING_SNAKE_CASE__     ,    2	) ^ self.ror(SCREAMING_SNAKE_CASE__     ,    13	) ^ self.ror(SCREAMING_SNAKE_CASE__     ,    22	)
     lowerCamelCase_						=    (a & b) ^ (a & c) ^ (b & c)
     lowerCamelCase_						=    (sa + maj) % 0X100_000_000

     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(SCREAMING_SNAKE_CASE__	)[2:].zfill(8	) for value in self.hashes]	)







  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   return 0Xff_fff_fff & (value << (32 - rotations)) | (value >> rotations)





class 	snake_case       (       unittest.TestCase     ):





  """simple docstring"""




  def     snake_case						(       self	):







   """simple docstring"""
   import hashlib

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





def __snake_case   ( ):
 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(snake_case__   ,							"utf-8"						)

 print(SHAaaa(snake_case__						).hash						)


if __name__ == "__main__":
     main()







"""simple docstring"""






from __future__ import annotations

from math import pi
from typing import Protocol

import matplotlib.pyplot as plt
import numpy as np






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	float:

					"""simple docstring"""



					return 0.0





def 				A_       ( snake_case__       ,					snake_case__		)					->  tuple[int | float, int | float]:
			_UpperCamelCase					:Union[str, Any]					     =	min([-20, np.min(fft_results[1 : samplerate // 2 - 1]		)]		)
			_UpperCamelCase					:Optional[int]					     =	max([20, np.max(fft_results[1 : samplerate // 2 - 1]		)]		)
			return lowest, highest





def 				A_       ( snake_case__       ,					snake_case__		)					->  None:
			_UpperCamelCase					:List[str]					     =	5_12
			_UpperCamelCase					:int					     =	[1] + [0] * (size - 1)
			_UpperCamelCase					:Union[str, Any]					     =	[filter_type.process(snake_case__		) for item in inputs]

			_UpperCamelCase					:Any					     =	[0] * (samplerate - size)  # zero-padding
			outputs += filler
			_UpperCamelCase					:int					     =	np.abs(np.fft.fft(snake_case__		)		)
			_UpperCamelCase					:str					     =	20 * np.logaa(snake_case__		)

			# Frequencies on log scale from 24 to nyquist frequency
			plt.xlim(24       ,					samplerate / 2 - 1		)
			plt.xlabel('''Frequency (Hz)'''		)
			plt.xscale('''log'''		)

			# Display within reasonable bounds
			_UpperCamelCase					:Tuple					     =	get_bounds(snake_case__       ,					snake_case__		)
			plt.ylim(max([-80, bounds[0]]		)       ,					min([80, bounds[1]]		)		)
			plt.ylabel('''Gain (dB)'''		)

			plt.plot(snake_case__		)
			plt.show()





def 				A_       ( snake_case__       ,					snake_case__		)					->  None:
			_UpperCamelCase					:Tuple					     =	5_12
			_UpperCamelCase					:Union[str, Any]					     =	[1] + [0] * (size - 1)
			_UpperCamelCase					:List[Any]					     =	[filter_type.process(snake_case__		) for item in inputs]

			_UpperCamelCase					:str					     =	[0] * (samplerate - size)  # zero-padding
			outputs += filler
			_UpperCamelCase					:Tuple					     =	np.angle(np.fft.fft(snake_case__		)		)

			# Frequencies on log scale from 24 to nyquist frequency
			plt.xlim(24       ,					samplerate / 2 - 1		)
			plt.xlabel('''Frequency (Hz)'''		)
			plt.xscale('''log'''		)

			plt.ylim(-2 * pi       ,					2 * pi		)
			plt.ylabel('''Phase shift (Radians)'''		)
			plt.plot(np.unwrap(snake_case__       ,					-2 * pi		)		)
			plt.show()

