
import itertools
import string
from collections.abc import Generator, Iterable

def 		UpperCamelCase						(   lowercase_			,			lowercase_ )		->						Generator[tuple[str, ...], None, None]:


  '''simple docstring'''






  lowercase__	: Any     		=   iter(lowercase_ )
  while True:
    lowercase__	: Any     		=   tuple(itertools.islice(lowercase_			,			lowercase_ ) )
    if not chunk:
      return
    yield chunk

def 		UpperCamelCase						(   lowercase_ )		->						str:


  '''simple docstring'''






  lowercase__	: Union[str, Any]     		=   """""".join([c.upper() for c in dirty if c in string.ascii_letters] )
  lowercase__	: Union[str, Any]     		=   """"""

  if len(lowercase_ ) < 2:
    return dirty

  for i in range(len(lowercase_ ) - 1 ):
    clean += dirty[i]

    if dirty[i] == dirty[i + 1]:
      clean += "X"

  clean += dirty[-1]

  if len(lowercase_ ) & 1:
    clean += "X"

  return clean

def 		UpperCamelCase						(   lowercase_ )		->						list[str]:


  '''simple docstring'''






  lowercase__	: Optional[Any]     		=   """ABCDEFGHIKLMNOPQRSTUVWXYZ"""
  # we're using a list instead of a '2d' array because it makes the math
  # for setting up the table and doing the actual encoding/decoding simpler
  lowercase__	: List[Any]     		=   []

  # copy key chars into the table if they are in `alphabet` ignoring duplicates
  for char in key.upper():
    if char not in table and char in alphabet:
      table.append(lowercase_ )

    # fill the rest of the table in with the remaining alphabet chars
  for char in alphabet:
    if char not in table:
      table.append(lowercase_ )

  return table

def 		UpperCamelCase						(   lowercase_			,			lowercase_ )		->						str:


  '''simple docstring'''






  lowercase__	: str     		=   generate_table(lowercase_ )
  lowercase__	: Optional[int]     		=   prepare_input(lowercase_ )
  lowercase__	: Optional[int]     		=   """"""

  # https://en.wikipedia.org/wiki/Playfair_cipher#Description
  for chara, chara in chunker(lowercase_			,			2 ):
    lowercase__		,     lowercase__	: Dict     		=   divmod(table.index(lowercase_ )			,			5 )
    lowercase__		,     lowercase__	: Optional[int]     		=   divmod(table.index(lowercase_ )			,			5 )

    if rowa == rowa:
      ciphertext += table[rowa * 5 + (cola + 1) % 5]
      ciphertext += table[rowa * 5 + (cola + 1) % 5]
    elif cola == cola:
      ciphertext += table[((rowa + 1) % 5) * 5 + cola]
      ciphertext += table[((rowa + 1) % 5) * 5 + cola]
    else:  # rectangle
      ciphertext += table[rowa * 5 + cola]
      ciphertext += table[rowa * 5 + cola]

  return ciphertext



def 		UpperCamelCase						(   lowercase_			,			lowercase_ )		->						str:


  '''simple docstring'''






  lowercase__	: int     		=   generate_table(lowercase_ )
  lowercase__	: Tuple     		=   """"""

  # https://en.wikipedia.org/wiki/Playfair_cipher#Description
  for chara, chara in chunker(lowercase_			,			2 ):
    lowercase__		,     lowercase__	: Optional[int]     		=   divmod(table.index(lowercase_ )			,			5 )
    lowercase__		,     lowercase__	: int     		=   divmod(table.index(lowercase_ )			,			5 )

    if rowa == rowa:
      plaintext += table[rowa * 5 + (cola - 1) % 5]
      plaintext += table[rowa * 5 + (cola - 1) % 5]
    elif cola == cola:
      plaintext += table[((rowa - 1) % 5) * 5 + cola]
      plaintext += table[((rowa - 1) % 5) * 5 + cola]
    else:  # rectangle
      plaintext += table[rowa * 5 + cola]
      plaintext += table[rowa * 5 + cola]

  return plaintext








def 		UpperCamelCase						(   lowercase_ )		->						int:


  '''simple docstring'''






  if n == 1 or not isinstance(lowercase_			,			lowercase_ ):
    return 0
  elif n == 2:
    return 1
  else:
    lowercase__	: List[Any]     		=   [0, 1]
    for i in range(2			,			n + 1 ):
      sequence.append(sequence[i - 1] + sequence[i - 2] )

    return sequence[n]

def 		UpperCamelCase						(   lowercase_ )		->						int:


  '''simple docstring'''






  lowercase__	: Optional[Any]     		=   0
  lowercase__	: Dict     		=   2

  while digits < n:
    index += 1
    lowercase__	: str     		=   len(str(fibonacci(lowercase_ ) ) )

  return index

def 		UpperCamelCase						(   lowercase_ = 10_00 )		->						int:


  '''simple docstring'''






  return fibonacci_digits_index(lowercase_ )


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






