

import re
from typing import Callable, List, Optional, Union

import tensorflow as tf


try:
      from tensorflow.keras.optimizers.legacy import Adam
except ImportError:
      from tensorflow.keras.optimizers import Adam




class      UpperCamelCase (     tf.keras.optimizers.schedules.LearningRateSchedule   ):

    def __init__(			self :      List[str]							,    snake_case__ :      float							,    snake_case__ :      Callable							,    snake_case__ :      int							,    snake_case__ :      float = 1.0							,    snake_case__ :      str = None							,    ):

     """simple docstring"""






     super().__init__()
     SCREAMING_SNAKE_CASE								=			initial_learning_rate
     SCREAMING_SNAKE_CASE								=			warmup_steps
     SCREAMING_SNAKE_CASE								=			power
     SCREAMING_SNAKE_CASE								=			decay_schedule_fn
     SCREAMING_SNAKE_CASE								=			name

    def __call__(			self :      List[str]							,    snake_case__ :      List[str]    ):

     """simple docstring"""






     with tf.name_scope(self.name or 'WarmUp'    ) as name:
      # Implements polynomial warmup. i.e., if global_step < warmup_steps, the
      # learning rate will be `global_step/num_warmup_steps * init_lr`.
      SCREAMING_SNAKE_CASE								=			tf.cast(snake_case__							,    tf.floataa    )
      SCREAMING_SNAKE_CASE								=			tf.cast(self.warmup_steps							,    tf.floataa    )
      SCREAMING_SNAKE_CASE								=			global_step_float / warmup_steps_float
      SCREAMING_SNAKE_CASE								=			self.initial_learning_rate * tf.math.pow(snake_case__							,    self.power    )
      return tf.cond(
          global_step_float < warmup_steps_float							,    lambda: warmup_learning_rate							,    lambda: self.decay_schedule_fn(step - self.warmup_steps    )							,    name=snake_case__							,    )




    def UpperCamelCase			(			self :      Any    ):

     """simple docstring"""






     return {
         "initial_learning_rate": self.initial_learning_rate,
         "decay_schedule_fn": self.decay_schedule_fn,
         "warmup_steps": self.warmup_steps,
         "power": self.power,
         "name": self.name,
     }


def        __lowerCAmelCase    (       _UpperCamelCase		:  Any		,							_UpperCamelCase		:  List[str]		,							_UpperCamelCase		:  Optional[Any]		,							_UpperCamelCase		:  Tuple = 0.0		,							_UpperCamelCase		:  Optional[Any] = 0.9		,							_UpperCamelCase		:  List[str] = 0.9_99		,							_UpperCamelCase		:  Optional[Any] = 1e-8		,							_UpperCamelCase		:  List[str] = None		,							_UpperCamelCase		:  Optional[Any] = None		,							_UpperCamelCase		:  Any = 0.0		,							_UpperCamelCase		:  int = 1.0		,							_UpperCamelCase		:  int = None		,							)		->							Tuple:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			tf.keras.optimizers.schedules.PolynomialDecay(
     initial_learning_rate=__UpperCAmelCase		,							decay_steps=num_train_steps - num_warmup_steps		,							end_learning_rate=init_lr * min_lr_ratio		,							power=__UpperCAmelCase		,							)
 if num_warmup_steps:
  SCREAMING_SNAKE_CASE								=			WarmUp(
      initial_learning_rate=__UpperCAmelCase		,							decay_schedule_fn=__UpperCAmelCase		,							warmup_steps=__UpperCAmelCase		,							)
 if weight_decay_rate > 0.0:
  SCREAMING_SNAKE_CASE								=			AdamWeightDecay(
      learning_rate=__UpperCAmelCase		,							weight_decay_rate=__UpperCAmelCase		,							beta_a=__UpperCAmelCase		,							beta_a=__UpperCAmelCase		,							epsilon=__UpperCAmelCase		,							clipnorm=__UpperCAmelCase		,							global_clipnorm=__UpperCAmelCase		,							exclude_from_weight_decay=['LayerNorm', 'layer_norm', 'bias']		,							include_in_weight_decay=__UpperCAmelCase		,							)
 else:
  SCREAMING_SNAKE_CASE								=			tf.keras.optimizers.Adam(
      learning_rate=__UpperCAmelCase		,							beta_a=__UpperCAmelCase		,							beta_a=__UpperCAmelCase		,							epsilon=__UpperCAmelCase		,							clipnorm=__UpperCAmelCase		,							global_clipnorm=__UpperCAmelCase		,							)
 # We return the optimizer and the LR scheduler in order to better track the
 # evolution of the LR independently of the optimizer.
 return optimizer, lr_schedule




class      UpperCamelCase (     _snake_case   ):

    def __init__(			self :      List[Any]							,    snake_case__ :      Union[float, tf.keras.optimizers.schedules.LearningRateSchedule] = 0.001							,    snake_case__ :      float = 0.9							,    snake_case__ :      float = 0.999							,    snake_case__ :      float = 1E-7							,    snake_case__ :      bool = False							,    snake_case__ :      float = 0.0							,    snake_case__ :      Optional[List[str]] = None							,    snake_case__ :      Optional[List[str]] = None							,    snake_case__ :      str = "AdamWeightDecay"							,    **snake_case__ :      str							,    ):

     """simple docstring"""






     super().__init__(snake_case__							,    snake_case__							,    snake_case__							,    snake_case__							,    snake_case__							,    snake_case__							,    **snake_case__    )
     SCREAMING_SNAKE_CASE								=			weight_decay_rate
     SCREAMING_SNAKE_CASE								=			include_in_weight_decay
     SCREAMING_SNAKE_CASE								=			exclude_from_weight_decay

    @classmethod
    def UpperCamelCase			(			cls :      int							,    snake_case__ :      Optional[int]    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			{'WarmUp': WarmUp}
     return super(snake_case__							,    cls    ).from_config(snake_case__							,    custom_objects=snake_case__    )

    def UpperCamelCase			(			self :      Dict							,    snake_case__ :      Dict							,    snake_case__ :      Dict							,    snake_case__ :      Optional[Any]    ):

     """simple docstring"""






     super(snake_case__							,    self    )._prepare_local(snake_case__							,    snake_case__							,    snake_case__    )
     SCREAMING_SNAKE_CASE								=			tf.constant(
         self.weight_decay_rate							,    name='adam_weight_decay_rate'    )

    def UpperCamelCase			(			self :      List[Any]							,    snake_case__ :      Any							,    snake_case__ :      Tuple							,    snake_case__ :      List[str]    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			self._do_use_weight_decay(var.name    )
     if do_decay:
      return var.assign_sub(
          learning_rate * var * apply_state[(var.device, var.dtype.base_dtype)]['weight_decay_rate']							,    use_locking=self._use_locking							,    )
     return tf.no_op()

    def UpperCamelCase			(			self :      List[str]							,    snake_case__ :      int							,    snake_case__ :      Dict=None							,    **snake_case__ :      int    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			list(zip(*snake_case__    )    )
     return super(snake_case__							,    self    ).apply_gradients(zip(snake_case__							,    snake_case__    )							,    name=snake_case__							,    **snake_case__    )

    def UpperCamelCase			(			self :      List[Any]							,    snake_case__ :      List[str]							,    snake_case__ :      Optional[int]							,    snake_case__ :      Any    ):

     """simple docstring"""






     if apply_state is None:
      return self._decayed_lr_t[var_dtype], {}

     SCREAMING_SNAKE_CASE								=			apply_state or {}
     SCREAMING_SNAKE_CASE								=			apply_state.get((var_device, var_dtype)    )
     if coefficients is None:
      SCREAMING_SNAKE_CASE								=			self._fallback_apply_state(snake_case__							,    snake_case__    )
      SCREAMING_SNAKE_CASE								=			coefficients

     return coefficients["lr_t"], {"apply_state": apply_state}

    def UpperCamelCase			(			self :      List[str]							,    snake_case__ :      Any							,    snake_case__ :      Optional[Any]							,    snake_case__ :      List[str]=None    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			self._get_lr(var.device							,    var.dtype.base_dtype							,    snake_case__    )
     SCREAMING_SNAKE_CASE								=			self._decay_weights_op(snake_case__							,    snake_case__							,    snake_case__    )
     with tf.control_dependencies([decay]    ):
      return super(snake_case__							,    self    )._resource_apply_dense(snake_case__							,    snake_case__							,    **snake_case__    )

    def UpperCamelCase			(			self :      Dict							,    snake_case__ :      Dict							,    snake_case__ :      int							,    snake_case__ :      Tuple							,    snake_case__ :      Union[str, Any]=None    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE						,	SCREAMING_SNAKE_CASE								=			self._get_lr(var.device							,    var.dtype.base_dtype							,    snake_case__    )
     SCREAMING_SNAKE_CASE								=			self._decay_weights_op(snake_case__							,    snake_case__							,    snake_case__    )
     with tf.control_dependencies([decay]    ):
      return super(snake_case__							,    self    )._resource_apply_sparse(snake_case__							,    snake_case__							,    snake_case__							,    **snake_case__    )

    def UpperCamelCase			(			self :      Union[str, Any]    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			super().get_config()
     config.update({'weight_decay_rate': self.weight_decay_rate}    )
     return config




    def UpperCamelCase			(			self :      Optional[Any]							,    snake_case__ :      Optional[int]    ):

     """simple docstring"""






     if self.weight_decay_rate == 0:
      return False

     if self._include_in_weight_decay:
      for r in self._include_in_weight_decay:
       if re.search(snake_case__							,    snake_case__    ) is not None:
        return True

     if self._exclude_from_weight_decay:
      for r in self._exclude_from_weight_decay:
       if re.search(snake_case__							,    snake_case__    ) is not None:
        return False
     return True




class      UpperCamelCase (     _snake_case   ):

    def __init__(			self :      Any    ):

     """simple docstring"""






     SCREAMING_SNAKE_CASE								=			[]
     SCREAMING_SNAKE_CASE								=			None

    @property
    def UpperCamelCase			(			self :      int    ):

     """simple docstring"""






     if self._accum_steps is None:
      SCREAMING_SNAKE_CASE								=			tf.Variable(
          tf.constant(0							,    dtype=tf.intaa    )							,    trainable=snake_case__							,    synchronization=tf.VariableSynchronization.ON_READ							,    aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA							,    )

     return self._accum_steps.value()

    @property
    def UpperCamelCase			(			self :      Any    ):

     """simple docstring"""






     if not self._gradients:
      raise ValueError('The accumulator should be called first to initialize the gradients'    )
     return [gradient.value() if gradient is not None else gradient for gradient in self._gradients]

    def __call__(			self :      str							,    snake_case__ :      Any    ):

     """simple docstring"""






     if not self._gradients:
      SCREAMING_SNAKE_CASE								=			self.step  # Create the step variable.
      self._gradients.extend(
          [
              tf.Variable(
                  tf.zeros_like(snake_case__    )							,    trainable=snake_case__							,    synchronization=tf.VariableSynchronization.ON_READ							,    aggregation=tf.VariableAggregation.ONLY_FIRST_REPLICA							,    )
              if gradient is not None
              else gradient
              for gradient in gradients
          ]    )
     if len(snake_case__    ) != len(self._gradients    ):
      raise ValueError(F"""Expected {len(self._gradients    )} gradients, but got {len(snake_case__    )}"""    )

     for accum_gradient, gradient in zip(self._gradients							,    snake_case__    ):
      if accum_gradient is not None and gradient is not None:
       accum_gradient.assign_add(snake_case__    )

     self._accum_steps.assign_add(1    )




    def UpperCamelCase			(			self :      List[Any]    ):

     """simple docstring"""






     if not self._gradients:
      return
     self._accum_steps.assign(0    )
     for gradient in self._gradients:
      if gradient is not None:
       gradient.assign(tf.zeros_like(snake_case__    )    )







def        __lowerCAmelCase    (       _UpperCamelCase		:  int = 10_00	)		->							int:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE								=			2**power
 SCREAMING_SNAKE_CASE								=			str(_UpperCamelCase	)
 SCREAMING_SNAKE_CASE								=			list(_UpperCamelCase	)
 SCREAMING_SNAKE_CASE								=			0

 for i in list_num:
  sum_of_num += int(_UpperCamelCase	)

 return sum_of_num


if __name__ == "__main__":
      a_    :						List[str]    		=      int(input("Enter the power of 2: ").strip())
      print("2 ^ ", power, " = ", 2**power)
      a_    :						int    		=      solution(power)
      print("Sum of the digits is: ", result)

