






'''simple docstring'''



import math

import tensorflow as tf
from packaging import version


def 				lowercase_					(     __A			:							str      )							->   List[Any]:



 """simple docstring"""




 lowercase       : int						=tf.convert_to_tensor(__A      )
 lowercase       : Dict						=0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0      )       ,   x.dtype      )      ))

 return x * cdf


def 				lowercase_					(     __A			:							Any      )							->   int:



 """simple docstring"""




 lowercase       : Optional[Any]						=tf.convert_to_tensor(__A      )
 lowercase       : Tuple						=tf.cast(math.pi       ,   x.dtype      )
 lowercase       : List[Any]						=tf.cast(0.044715       ,   x.dtype      )
 lowercase       : Optional[Any]						=0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi      ) * (x + coeff * tf.pow(__A       ,   3      ))      ))

 return x * cdf


def 				lowercase_					(     __A			:							List[str]      )							->   Optional[Any]:



 """simple docstring"""




 lowercase       : Optional[int]						=tf.convert_to_tensor(__A      )

 return x * tf.tanh(tf.math.softplus(__A      )      )


def 				lowercase_					(     __A			:							Dict      )							->   Union[str, Any]:



 """simple docstring"""




 lowercase       : Union[str, Any]						=tf.convert_to_tensor(__A      )
 lowercase       : Tuple						=tf.cast(0.044715       ,   x.dtype      )
 lowercase       : Any						=tf.cast(0.7978845608       ,   x.dtype      )

 return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x)      ))


def 				lowercase_					(     __A			:							Optional[Any]      )							->   Dict:



 """simple docstring"""




 lowercase       : List[str]						=tf.convert_to_tensor(__A      )
 lowercase       : Optional[int]						=tf.cast(1.702       ,   x.dtype      )
 return x * tf.math.sigmoid(coeff * x      )


def 				lowercase_					(     __A			:							Dict      )							->   Union[str, Any]:



 """simple docstring"""




 return tf.clip_by_value(_gelu(__A      )       ,   -1_0       ,   1_0      )


def 				lowercase_					(     __A			:							Optional[Any]       ,   __A			:							int=-1      )							->   Tuple:



 """simple docstring"""




 lowercase	,		lowercase       : List[Any]						=tf.split(__A       ,   2       ,   axis=__A      )
 return a * tf.math.sigmoid(__A      )


if version.parse(tf.version.VERSION) >= version.parse('2.4'):


      def 				lowercase_					(     __A			:							str      )							->   Optional[int]:



       """simple docstring"""




       return tf.keras.activations.gelu(__A       ,   approximate=__A      )

      SCREAMING_SNAKE_CASE							=						tf.keras.activations.gelu





      SCREAMING_SNAKE_CASE							=						approximate_gelu_wrap
else:
      SCREAMING_SNAKE_CASE							=						_gelu
      SCREAMING_SNAKE_CASE							=						_gelu_new


SCREAMING_SNAKE_CASE							=						{
    'gelu': gelu,
    'gelu_10': gelu_aa,
    'gelu_fast': gelu_fast,
    'gelu_new': gelu_new,
    'glu': glu,
    'mish': mish,
    'quick_gelu': quick_gelu,
    'relu': tf.keras.activations.relu,
    'sigmoid': tf.keras.activations.sigmoid,
    'silu': tf.keras.activations.swish,
    'swish': tf.keras.activations.swish,
    'tanh': tf.keras.activations.tanh,
}





def 				lowercase_					(     __A			:							Optional[int]      )							->   Optional[int]:



 """simple docstring"""




 if activation_string in ACTaFN:
  return ACTaFN[activation_string]
 else:
  raise KeyError(F'function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()      )}'      )











'''simple docstring'''



def 				lowercase_					(     __A			:							int      )							->   int:



 """simple docstring"""




 if n == 1 or not isinstance(__A       ,   __A      ):
  return 0
 elif n == 2:
  return 1
 else:
  lowercase       : Tuple						=[0, 1]
  for i in range(2       ,   n + 1      ):
   sequence.append(sequence[i - 1] + sequence[i - 2]      )

  return sequence[n]


def 				lowercase_					(     __A			:							int      )							->   int:



 """simple docstring"""




 lowercase       : List[str]						=0
 lowercase       : str						=2

 while digits < n:
  index += 1
  lowercase       : int						=len(str(fibonacci(__A      )      )      )

 return index


def 				lowercase_					(     __A			:							int = 1_0_0_0      )							->   int:



 """simple docstring"""




 return fibonacci_digits_index(__A      )


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



