

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
       import tensorflow as tf
       from tensorflow.python.eager import context
       from tensorflow.python.framework import ops

       from transformers import GradientAccumulator, create_optimizer







@require_tf
class 						__magic_name__			(							unittest.TestCase							):

   '''simple docstring'''




   def  _UpperCAmelCase (				self,    lowercase_,    lowercase_,    lowercase_       )							->    str:






     """simple docstring"""






     self.assertEqual(len(lowercase_       ),    len(lowercase_       )       )
     for a, b in zip(lowercase_,    lowercase_       ):
       self.assertAlmostEqual(lowercase_,    lowercase_,    delta=lowercase_       )



   def  _UpperCAmelCase (				self       )							->    Optional[Any]:






     """simple docstring"""






     a__  =GradientAccumulator()
     accumulator([tf.constant([1.0, 2.0]       )]       )
     accumulator([tf.constant([-2.0, 1.0]       )]       )
     accumulator([tf.constant([-1.0, 2.0]       )]       )
     with self.assertRaises(lowercase_       ):
       accumulator([tf.constant([1.0, 1.0]       ), tf.constant([2.0, 2.0]       )]       )
     self.assertEqual(accumulator.step,    3       )
     self.assertEqual(len(accumulator.gradients       ),    1       )
     self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist(),    [-2.0, 5.0],    tol=1E-2       )
     accumulator.reset()
     self.assertEqual(accumulator.step,    0       )
     self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist(),    [0.0, 0.0],    tol=1E-2       )



   def  _UpperCAmelCase (				self       )							->    int:






     """simple docstring"""






     a__  =None
     ops.enable_eager_execution_internal()
     a__  =tf.config.list_physical_devices('''CPU'''       )
     if len(lowercase_       ) == 1:
       tf.config.set_logical_device_configuration(
           physical_devices[0],    [tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]       )
     a__  =tf.config.list_logical_devices(device_type='''CPU'''       )
     a__  =tf.distribute.MirroredStrategy(devices=devices[:2]       )

     with strategy.scope():
       a__  =GradientAccumulator()
       a__  =tf.Variable([4.0, 3.0]       )
       a__,      a__  =create_optimizer(5E-5,    10,    5       )
       a__  =tf.Variable([0.0, 0.0],    trainable=lowercase_       )

     def accumulate_on_replica(lowercase_       ):
       accumulator([gradient]       )

     def apply_on_replica():
       optimizer.apply_gradients(list(zip(accumulator.gradients,    [variable]       )       )       )

     @tf.function
     def accumulate(lowercase_,    lowercase_       ):
       with strategy.scope():
         a__  =strategy.experimental_local_results(lowercase_       )
         local_variables[0].assign(lowercase_       )
         local_variables[1].assign(lowercase_       )
         strategy.run(lowercase_,    args=(gradient_placeholder,)       )

     @tf.function
     def apply_grad():
       with strategy.scope():
         strategy.run(lowercase_       )

     def _check_local_values(lowercase_,    lowercase_       ):
       a__  =strategy.experimental_local_results(accumulator._gradients[0]       )
       self.assertListAlmostEqual(values[0].value(),    lowercase_,    tol=1E-2       )
       self.assertListAlmostEqual(values[1].value(),    lowercase_,    tol=1E-2       )

     accumulate([1.0, 2.0],    [-1.0, 1.0]       )
     accumulate([3.0, -1.0],    [-1.0, -1.0]       )
     accumulate([-2.0, 2.0],    [3.0, -2.0]       )
     self.assertEqual(accumulator.step,    3       )
     _check_local_values([2.0, 3.0],    [1.0, -2.0]       )
     apply_grad()
     self.assertListAlmostEqual(variable.value(),    [4.0, 3.0],    tol=1E-2       )
     accumulator.reset()
     self.assertEqual(accumulator.step,    0       )
     _check_local_values([0.0, 0.0],    [0.0, 0.0]       )



from math import factorial




def 			UpperCAmelCase__				(			_A      : int = 1_00							):





  '''simple docstring'''







  return sum(int(_A							) for x in str(factorial(_A							)							)							)


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