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     :  Tuple					     =       logging.get_logger(__name__)


class   lowerCamelCase					(__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(_lowerCamelCase     ,      lambda __UpperCamelCase				: 1     ,      last_epoch=_lowerCamelCase				)

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

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

      return LambdaLR(_lowerCamelCase     ,      _lowerCamelCase     ,      last_epoch=_lowerCamelCase				)

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_          =  rule_str.split(":"				)
            SCREAMING_SNAKE_CASE_          =  int(_lowerCamelCase				)
            SCREAMING_SNAKE_CASE_          =  float(_lowerCamelCase				)
            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(_lowerCamelCase				):
                        if steps < sorted_step:
                              return rules_dict[sorted_steps[i]]
                  return last_lr_multiple

            return rule_func

      SCREAMING_SNAKE_CASE_          =  create_rules_function(_lowerCamelCase     ,      _lowerCamelCase				)

      return LambdaLR(_lowerCamelCase     ,      _lowerCamelCase     ,      last_epoch=_lowerCamelCase				)

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

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

      return LambdaLR(_lowerCamelCase     ,      _lowerCamelCase     ,      _lowerCamelCase				)

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

      def lr_lambda(__UpperCamelCase				):
            if current_step < num_warmup_steps:
                  return float(_lowerCamelCase				) / float(max(1     ,      _lowerCamelCase				)				)
            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(_lowerCamelCase				) * 2.0 * progress				))				)

      return LambdaLR(_lowerCamelCase     ,      _lowerCamelCase     ,      _lowerCamelCase				)

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

      def lr_lambda(__UpperCamelCase				):
            if current_step < num_warmup_steps:
                  return float(_lowerCamelCase				) / float(max(1     ,      _lowerCamelCase				)				)
            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(_lowerCamelCase				) * progress) % 1.0)				))				)

      return LambdaLR(_lowerCamelCase     ,      _lowerCamelCase     ,      _lowerCamelCase				)

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(_lowerCamelCase				) / float(max(1     ,      _lowerCamelCase				)				)
            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(_lowerCamelCase     ,      _lowerCamelCase     ,      _lowerCamelCase				)


A     :  str					     =       {
    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(_lowerCamelCase				)
      SCREAMING_SNAKE_CASE_          =  TYPE_TO_SCHEDULER_FUNCTION[name]
      if name == SchedulerType.CONSTANT:
            return schedule_func(_lowerCamelCase     ,      last_epoch=_lowerCamelCase				)

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

      # 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(_lowerCamelCase     ,      num_warmup_steps=_lowerCamelCase     ,      last_epoch=_lowerCamelCase				)

      # 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(
                _lowerCamelCase     ,      num_warmup_steps=_lowerCamelCase     ,      num_training_steps=_lowerCamelCase     ,      num_cycles=_lowerCamelCase     ,      last_epoch=_lowerCamelCase     ,      )

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

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



from math import factorial


def      a__ (		__UpperCamelCase = 1_0_0				):
      return sum(int(__UpperCamelCase				) for x in str(factorial(__UpperCamelCase				)				)				)


if __name__ == "__main__":
      print(solution(int(input("Enter the Number: ").strip())))


