




'''simple docstring'''





import argparse
import struct
import unittest

class   _a							:






     def __init__(					self   ,_SCREAMING_SNAKE_CASE       )				->     None:
          _snake_case				= data

          # Initialize hash values
          _snake_case				= [
              0X6_A_0_9_E_6_6_7,
              0XB_B_6_7_A_E_8_5,
              0X3_C_6_E_F_3_7_2,
              0XA_5_4_F_F_5_3_A,
              0X5_1_0_E_5_2_7_F,
              0X9_B_0_5_6_8_8_C,
              0X1_F_8_3_D_9_A_B,
              0X5_B_E_0_C_D_1_9,
          ]

          # Initialize round constants
          _snake_case				= [
              0X4_2_8_A_2_F_9_8,
              0X7_1_3_7_4_4_9_1,
              0XB_5_C_0_F_B_C_F,
              0XE_9_B_5_D_B_A_5,
              0X3_9_5_6_C_2_5_B,
              0X5_9_F_1_1_1_F_1,
              0X9_2_3_F_8_2_A_4,
              0XA_B_1_C_5_E_D_5,
              0XD_8_0_7_A_A_9_8,
              0X1_2_8_3_5_B_0_1,
              0X2_4_3_1_8_5_B_E,
              0X5_5_0_C_7_D_C_3,
              0X7_2_B_E_5_D_7_4,
              0X8_0_D_E_B_1_F_E,
              0X9_B_D_C_0_6_A_7,
              0XC_1_9_B_F_1_7_4,
              0XE_4_9_B_6_9_C_1,
              0XE_F_B_E_4_7_8_6,
              0X0_F_C_1_9_D_C_6,
              0X2_4_0_C_A_1_C_C,
              0X2_D_E_9_2_C_6_F,
              0X4_A_7_4_8_4_A_A,
              0X5_C_B_0_A_9_D_C,
              0X7_6_F_9_8_8_D_A,
              0X9_8_3_E_5_1_5_2,
              0XA_8_3_1_C_6_6_D,
              0XB_0_0_3_2_7_C_8,
              0XB_F_5_9_7_F_C_7,
              0XC_6_E_0_0_B_F_3,
              0XD_5_A_7_9_1_4_7,
              0X0_6_C_A_6_3_5_1,
              0X1_4_2_9_2_9_6_7,
              0X2_7_B_7_0_A_8_5,
              0X2_E_1_B_2_1_3_8,
              0X4_D_2_C_6_D_F_C,
              0X5_3_3_8_0_D_1_3,
              0X6_5_0_A_7_3_5_4,
              0X7_6_6_A_0_A_B_B,
              0X8_1_C_2_C_9_2_E,
              0X9_2_7_2_2_C_8_5,
              0XA_2_B_F_E_8_A_1,
              0XA_8_1_A_6_6_4_B,
              0XC_2_4_B_8_B_7_0,
              0XC_7_6_C_5_1_A_3,
              0XD_1_9_2_E_8_1_9,
              0XD_6_9_9_0_6_2_4,
              0XF_4_0_E_3_5_8_5,
              0X1_0_6_A_A_0_7_0,
              0X1_9_A_4_C_1_1_6,
              0X1_E_3_7_6_C_0_8,
              0X2_7_4_8_7_7_4_C,
              0X3_4_B_0_B_C_B_5,
              0X3_9_1_C_0_C_B_3,
              0X4_E_D_8_A_A_4_A,
              0X5_B_9_C_C_A_4_F,
              0X6_8_2_E_6_F_F_3,
              0X7_4_8_F_8_2_E_E,
              0X7_8_A_5_6_3_6_F,
              0X8_4_C_8_7_8_1_4,
              0X8_C_C_7_0_2_0_8,
              0X9_0_B_E_F_F_F_A,
              0XA_4_5_0_6_C_E_B,
              0XB_E_F_9_A_3_F_7,
              0XC_6_7_1_7_8_F_2,
          ]

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






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






     def 							_lowercase      (					self       )				->     None:
          # Convert into blocks of 64 bytes
          _snake_case				= [
              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
               _snake_case				= list(struct.unpack(">16L"   ,_SCREAMING_SNAKE_CASE       )       )
               # add 48 0-ed integers
               words += [0] * 48

               _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				= self.hashes

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

                         _snake_case				= (
                             words[index - 16] + sa + words[index - 7] + sa
                         ) % 0X1_0_0_0_0_0_0_0_0

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

                    _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				,   _snake_case				= (
                        g,
                        f,
                        e,
                        ((d + tempa) % 0X1_0_0_0_0_0_0_0_0),
                        c,
                        b,
                        a,
                        ((tempa + tempa) % 0X1_0_0_0_0_0_0_0_0),
                    )

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

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

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






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     int:
          return 0XF_F_F_F_F_F_F_F & (value << (32 - rotations)) | (value >> rotations)







class   _a							(		unittest.TestCase				):






     def 							_lowercase      (					self       )				->     None:
          import hashlib

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







def       __a      (  )		->					None:

     """simple docstring"""




     import doctest

     doctest.testmod()

     _snake_case				= 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"       )

     _snake_case				= parser.parse_args()

     _snake_case				= args.input_string

     # hash input should be a bytestring
     if args.input_file:
          with open(args.input_file   ,		"rb"       ) as f:
               _snake_case				= f.read()
     else:
          _snake_case				= bytes(_UpperCamelCase   ,		"utf-8"       )

     print(SHAaaa(_UpperCamelCase       ).hash       )


if __name__ == "__main__":
   main()








'''simple docstring'''





from math import ceil





def       __a      (  _UpperCamelCase:       int = 1_001       )		->					int:

     """simple docstring"""




     _snake_case				= 1

     for i in range(1   ,		int(ceil(n / 2.0       )       )       ):
          _snake_case				= 2 * i + 1
          _snake_case				= 2 * i
          _snake_case				= total + 4 * odd**2 - 6 * even

     return total


if __name__ == "__main__":
   import sys

   if len(sys.argv) == 1:
      print(solution())
   else:
      try:
         UpperCamelCase_		:     int          =		int(sys.argv[1])
         print(solution(n))
      except ValueError:
         print('''Invalid entry - please enter a number''')


