






"""simple docstring"""


def 					lowerCAmelCase				(    ):




  """simple docstring"""







  __A									= [3_1, 2_8, 3_1, 3_0, 3_1, 3_0, 3_1, 3_1, 3_0, 3_1, 3_0, 3_1]

  __A									= 6
  __A									= 1
  __A									= 1_9_0_1

  __A									= 0

  while year < 2_0_0_1:
    day += 7

    if (year % 4 == 0 and year % 1_0_0 != 0) or (year % 4_0_0 == 0):
      if day > days_per_month[month - 1] and month != 2:
        month += 1
        __A									= day - days_per_month[month - 2]
      elif day > 2_9 and month == 2:
        month += 1
        __A									= day - 2_9
    else:
      if day > days_per_month[month - 1]:
        month += 1
        __A									= day - days_per_month[month - 2]

    if month > 1_2:
      year += 1
      __A									= 1

    if year < 2_0_0_1 and day == 1:
      sundays += 1
  return sundays


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












"""simple docstring"""


import argparse
import struct
import unittest


class 					snake_case		:


   '''simple docstring'''

   def __init__(	self :     Optional[int],       _lowerCamelCase :     bytes  ):

     '''simple docstring'''
     __A									= data

     # Initialize hash values
     __A									= [
         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
     __A									= [
         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,
     ]

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


   @staticmethod
   def 				_SCREAMING_SNAKE_CASE				(	_lowerCamelCase :     bytes  ):

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


   def 				_SCREAMING_SNAKE_CASE				(	self :     int  ):

     '''simple docstring'''
     # Convert into blocks of 64 bytes
     __A									= [
         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									= list(struct.unpack('''>16L''',       _lowerCamelCase  )  )
       # add 48 0-ed integers
       words += [0] * 48

       __A			,    __A			,    __A			,    __A			,    __A			,    __A			,    __A			,    __A									= self.hashes

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

           __A									= (
               words[index - 16] + sa + words[index - 7] + sa
           ) % 0X100_000_000

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

         __A			,    __A			,    __A			,    __A			,    __A			,    __A			,    __A			,    __A									= (
             g,
             f,
             e,
             ((d + tempa) % 0X100_000_000),
             c,
             b,
             a,
             ((tempa + tempa) % 0X100_000_000),
         )

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

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

     __A									= ''''''.join([hex(_lowerCamelCase  )[2:].zfill(8  ) for value in self.hashes]  )






   def 				_SCREAMING_SNAKE_CASE				(	self :     Union[str, Any],       _lowerCamelCase :     int,       _lowerCamelCase :     int  ):

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





class 					snake_case		(							unittest.TestCase						):


   '''simple docstring'''

   def 				_SCREAMING_SNAKE_CASE				(	self :     Dict  ):

     '''simple docstring'''
     import hashlib

     __A									= bytes('''Test String''',       '''utf-8'''  )
     self.assertEqual(SHAaaa(_lowerCamelCase  ).hash,       hashlib.shaaaa(_lowerCamelCase  ).hexdigest()  )





def 					lowerCAmelCase				(    ):




  """simple docstring"""







  import doctest

  doctest.testmod()

  __A									= 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									= parser.parse_args()

  __A									= args.input_string

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

  print(SHAaaa(__UpperCamelCase ).hash )


if __name__ == "__main__":
       main()




