




'''simple docstring'''






import argparse
import struct
import unittest






class        lowercase_      :





     def __init__(     self     :					Dict     ,							__lowerCamelCase     :					bytes			):
           snake_case__       :   Tuple	      =    data

           # Initialize hash values
           snake_case__       :   Any	      =    [
               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
           snake_case__       :   Union[str, Any]	      =    [
               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,
           ]

           snake_case__       :   str	      =    self.preprocessing(self.data			)
           self.final_hash()





     @staticmethod
     def 			_lowerCAmelCase      (     __lowerCamelCase     :					bytes			):
           snake_case__       :   List[Any]	      =    b'\x80' + (b'\x00' * (63 - (len(__lowerCamelCase			) + 8) % 64))
           snake_case__       :   Union[str, Any]	      =    struct.pack('>Q'     ,							(len(__lowerCamelCase			) * 8)			)
           return data + padding + big_endian_integer





     def 			_lowerCAmelCase      (     self     :					str			):
           # Convert into blocks of 64 bytes
           snake_case__       :   Tuple	      =    [
               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__       :   str	      =    list(struct.unpack('>16L'     ,							__lowerCamelCase			)			)
                 # add 48 0-ed integers
                 words += [0] * 48

                 snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__       :   Optional[int]	      =    self.hashes

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

                             snake_case__       :   Dict	      =    (
                                 words[index - 16] + sa + words[index - 7] + sa
                             ) % 0X100_000_000

                       # Compression
                       snake_case__       :   Dict	      =    self.ror(__lowerCamelCase     ,							6			) ^ self.ror(__lowerCamelCase     ,							11			) ^ self.ror(__lowerCamelCase     ,							25			)
                       snake_case__       :   Dict	      =    (e & f) ^ ((~e & 0XFF_FFF_FFF) & g)
                       snake_case__       :   List[str]	      =    (
                           h + sa + ch + self.round_constants[index] + words[index]
                       ) % 0X100_000_000
                       snake_case__       :   Tuple	      =    self.ror(__lowerCamelCase     ,							2			) ^ self.ror(__lowerCamelCase     ,							13			) ^ self.ror(__lowerCamelCase     ,							22			)
                       snake_case__       :   Tuple	      =    (a & b) ^ (a & c) ^ (b & c)
                       snake_case__       :   Tuple	      =    (sa + maj) % 0X100_000_000

                       snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__      ,							snake_case__       :   Union[str, Any]	      =    (
                           g,
                           f,
                           e,
                           ((d + tempa) % 0X100_000_000),
                           c,
                           b,
                           a,
                           ((tempa + tempa) % 0X100_000_000),
                       )

                 snake_case__       :   Union[str, Any]	      =    [a, b, c, d, e, f, g, h]

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

           snake_case__       :   int	      =    ''.join([hex(__lowerCamelCase			)[2:].zfill(8			) for value in self.hashes]			)





     def 			_lowerCAmelCase      (     self     :					List[Any]     ,							__lowerCamelCase     :					int     ,							__lowerCamelCase     :					int			):
           return 0XFF_FFF_FFF & (value << (32 - rotations)) | (value >> rotations)






class        lowercase_      (						unittest.TestCase							):





     def 			_lowerCAmelCase      (     self     :					str			):
           import hashlib

           snake_case__       :   Any	      =    bytes('Test String'     ,							'utf-8'			)
           self.assertEqual(SHAaaa(__lowerCamelCase			).hash     ,							hashlib.shaaaa(__lowerCamelCase			).hexdigest()			)






def 		UpperCamelCase__      (		)    ->   None:
      import doctest

      doctest.testmod()

      snake_case__       :   Tuple	      =    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__       :   Optional[Any]	      =    parser.parse_args()

      snake_case__       :   Any	      =    args.input_string

      # hash input should be a bytestring
      if args.input_file:
            with open(args.input_file				,      'rb'		) as f:
                  snake_case__       :   List[Any]	      =    f.read()
      else:
            snake_case__       :   Union[str, Any]	      =    bytes(__SCREAMING_SNAKE_CASE				,      'utf-8'		)

      print(SHAaaa(__SCREAMING_SNAKE_CASE		).hash		)


if __name__ == "__main__":
      main()






'''simple docstring'''






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   int:
      if n == 1 or not isinstance(__SCREAMING_SNAKE_CASE				,      __SCREAMING_SNAKE_CASE		):
            return 0
      elif n == 2:
            return 1
      else:
            snake_case__       :   int	      =    [0, 1]
            for i in range(2				,      n + 1		):
                  sequence.append(sequence[i - 1] + sequence[i - 2]		)

            return sequence[n]






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE		)    ->   int:
      snake_case__       :   Optional[int]	      =    0
      snake_case__       :   Dict	      =    2

      while digits < n:
            index += 1
            snake_case__       :   Optional[int]	      =    len(str(fibonacci(__SCREAMING_SNAKE_CASE		)		)		)

      return index






def 		UpperCamelCase__      (		__SCREAMING_SNAKE_CASE = 1000		)    ->   int:
      return fibonacci_digits_index(__SCREAMING_SNAKE_CASE		)


if __name__ == "__main__":
      print(solution(int(str(input()).strip())))
