import math
from enum import Enum
from typing import Optional, Union

from torch.optim import Optimizer
from torch.optim.lr_scheduler import LambdaLR

from .utils import logging


A   :     str       =				logging.get_logger(__name__)


class      lowerCamelCase    (SCREAMING_SNAKE_CASE__    ):
  """simple docstring"""







  lowerCamelCase__   =  '''linear'''
  lowerCamelCase__   =  '''cosine'''
  lowerCamelCase__   =  '''cosine_with_restarts'''
  lowerCamelCase__   =  '''polynomial'''
  lowerCamelCase__   =  '''constant'''
  lowerCamelCase__   =  '''constant_with_warmup'''
  lowerCamelCase__   =  '''piecewise_constant'''



def    a__       (						__UpperCamelCase   ,					__UpperCamelCase = -1 ):
      return LambdaLR(__UpperCamelCase   ,					lambda __UpperCamelCase : 1   ,					last_epoch=__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase = -1 ):

      def lr_lambda(__UpperCamelCase ):
            if current_step < num_warmup_steps:
                  return float(__UpperCamelCase ) / float(max(1.0   ,					__UpperCamelCase ) )
            return 1.0

      return LambdaLR(__UpperCamelCase   ,					__UpperCamelCase   ,					last_epoch=__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase = -1 ):
      SCREAMING_SNAKE_CASE_      =     {}
      SCREAMING_SNAKE_CASE_      =     step_rules.split("," )
      for rule_str in rule_list[:-1]:
            SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     rule_str.split(":" )
            SCREAMING_SNAKE_CASE_      =     int(__UpperCamelCase )
            SCREAMING_SNAKE_CASE_      =     float(__UpperCamelCase )
            SCREAMING_SNAKE_CASE_      =     value
      SCREAMING_SNAKE_CASE_      =     float(rule_list[-1] )

      def create_rules_function(__UpperCamelCase   ,					__UpperCamelCase ):
            def rule_func(__UpperCamelCase ) -> float:
                  SCREAMING_SNAKE_CASE_      =     sorted(rules_dict.keys() )
                  for i, sorted_step in enumerate(__UpperCamelCase ):
                        if steps < sorted_step:
                              return rules_dict[sorted_steps[i]]
                  return last_lr_multiple

            return rule_func

      SCREAMING_SNAKE_CASE_      =     create_rules_function(__UpperCamelCase   ,					__UpperCamelCase )

      return LambdaLR(__UpperCamelCase   ,					__UpperCamelCase   ,					last_epoch=__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=-1 ):

      def lr_lambda(__UpperCamelCase ):
            if current_step < num_warmup_steps:
                  return float(__UpperCamelCase ) / float(max(1   ,					__UpperCamelCase ) )
            return max(
                0.0   ,					float(num_training_steps - current_step ) / float(max(1   ,					num_training_steps - num_warmup_steps ) ) )

      return LambdaLR(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase = 0.5   ,					__UpperCamelCase = -1 ):

      def lr_lambda(__UpperCamelCase ):
            if current_step < num_warmup_steps:
                  return float(__UpperCamelCase ) / float(max(1   ,					__UpperCamelCase ) )
            SCREAMING_SNAKE_CASE_      =     float(current_step - num_warmup_steps ) / float(max(1   ,					num_training_steps - num_warmup_steps ) )
            return max(0.0   ,					0.5 * (1.0 + math.cos(math.pi * float(__UpperCamelCase ) * 2.0 * progress )) )

      return LambdaLR(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase = 1   ,					__UpperCamelCase = -1 ):

      def lr_lambda(__UpperCamelCase ):
            if current_step < num_warmup_steps:
                  return float(__UpperCamelCase ) / float(max(1   ,					__UpperCamelCase ) )
            SCREAMING_SNAKE_CASE_      =     float(current_step - num_warmup_steps ) / float(max(1   ,					num_training_steps - num_warmup_steps ) )
            if progress >= 1.0:
                  return 0.0
            return max(0.0   ,					0.5 * (1.0 + math.cos(math.pi * ((float(__UpperCamelCase ) * progress) % 1.0) )) )

      return LambdaLR(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=1E-7   ,					__UpperCamelCase=1.0   ,					__UpperCamelCase=-1 ):
      SCREAMING_SNAKE_CASE_      =     optimizer.defaults["lr"]
      if not (lr_init > lr_end):
            raise ValueError(F'''lr_end ({lr_end}) must be be smaller than initial lr ({lr_init})''' )

      def lr_lambda(__UpperCamelCase ):
            if current_step < num_warmup_steps:
                  return float(__UpperCamelCase ) / float(max(1   ,					__UpperCamelCase ) )
            elif current_step > num_training_steps:
                  return lr_end / lr_init  # as LambdaLR multiplies by lr_init
            else:
                  SCREAMING_SNAKE_CASE_      =     lr_init - lr_end
                  SCREAMING_SNAKE_CASE_      =     num_training_steps - num_warmup_steps
                  SCREAMING_SNAKE_CASE_      =     1 - (current_step - num_warmup_steps) / decay_steps
                  SCREAMING_SNAKE_CASE_      =     lr_range * pct_remaining**power + lr_end
                  return decay / lr_init  # as LambdaLR multiplies by lr_init

      return LambdaLR(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase )


A   :     Optional[Any]       =				{
    SchedulerType.LINEAR: get_linear_schedule_with_warmup,
    SchedulerType.COSINE: get_cosine_schedule_with_warmup,
    SchedulerType.COSINE_WITH_RESTARTS: get_cosine_with_hard_restarts_schedule_with_warmup,
    SchedulerType.POLYNOMIAL: get_polynomial_decay_schedule_with_warmup,
    SchedulerType.CONSTANT: get_constant_schedule,
    SchedulerType.CONSTANT_WITH_WARMUP: get_constant_schedule_with_warmup,
    SchedulerType.PIECEWISE_CONSTANT: get_piecewise_constant_schedule,
}





def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase = None   ,					__UpperCamelCase = None   ,					__UpperCamelCase = None   ,					__UpperCamelCase = 1   ,					__UpperCamelCase = 1.0   ,					__UpperCamelCase = -1   ,					):
      SCREAMING_SNAKE_CASE_      =     SchedulerType(__UpperCamelCase )
      SCREAMING_SNAKE_CASE_      =     TYPE_TO_SCHEDULER_FUNCTION[name]
      if name == SchedulerType.CONSTANT:
            return schedule_func(__UpperCamelCase   ,					last_epoch=__UpperCamelCase )

      if name == SchedulerType.PIECEWISE_CONSTANT:
            return schedule_func(__UpperCamelCase   ,					step_rules=__UpperCamelCase   ,					last_epoch=__UpperCamelCase )

      # All other schedulers require `num_warmup_steps`
      if num_warmup_steps is None:
            raise ValueError(F'''{name} requires `num_warmup_steps`, please provide that argument.''' )

      if name == SchedulerType.CONSTANT_WITH_WARMUP:
            return schedule_func(__UpperCamelCase   ,					num_warmup_steps=__UpperCamelCase   ,					last_epoch=__UpperCamelCase )

      # All other schedulers require `num_training_steps`
      if num_training_steps is None:
            raise ValueError(F'''{name} requires `num_training_steps`, please provide that argument.''' )

      if name == SchedulerType.COSINE_WITH_RESTARTS:
            return schedule_func(
                __UpperCamelCase   ,					num_warmup_steps=__UpperCamelCase   ,					num_training_steps=__UpperCamelCase   ,					num_cycles=__UpperCamelCase   ,					last_epoch=__UpperCamelCase   ,					)

      if name == SchedulerType.POLYNOMIAL:
            return schedule_func(
                __UpperCamelCase   ,					num_warmup_steps=__UpperCamelCase   ,					num_training_steps=__UpperCamelCase   ,					power=__UpperCamelCase   ,					last_epoch=__UpperCamelCase   ,					)

      return schedule_func(
          __UpperCamelCase   ,					num_warmup_steps=__UpperCamelCase   ,					num_training_steps=__UpperCamelCase   ,					last_epoch=__UpperCamelCase )



def    a__       (						__UpperCamelCase ):
      if n == 1 or not isinstance(__UpperCamelCase   ,					__UpperCamelCase ):
            return 0
      elif n == 2:
            return 1
      else:
            SCREAMING_SNAKE_CASE_      =     [0, 1]
            for i in range(2   ,					n + 1 ):
                  sequence.append(sequence[i - 1] + sequence[i - 2] )

            return sequence[n]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     0
      SCREAMING_SNAKE_CASE_      =     2

      while digits < n:
            index += 1
            SCREAMING_SNAKE_CASE_      =     len(str(fibonacci(__UpperCamelCase ) ) )

      return index


def    a__       (						__UpperCamelCase = 1_0_0_0 ):
      return fibonacci_digits_index(__UpperCamelCase )


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


