






'''simple docstring'''
import inspect
import os
import unittest
from dataclasses import dataclass

import torch

from accelerate import Accelerator, DistributedDataParallelKwargs, GradScalerKwargs
from accelerate.state import AcceleratorState
from accelerate.test_utils import execute_subprocess_async, require_cuda, require_multi_gpu
from accelerate.utils import KwargsHandler






@dataclass
class        __SCREAMING_SNAKE_CASE (     lowerCamelCase			):
 snake_case_												=							0
 snake_case_												=							False
 snake_case_												=							3.0






class        __SCREAMING_SNAKE_CASE (     unittest.TestCase			):




 def        __magic_name__		( self		:							List[Any] )		->  Optional[Any]:
       # If no defaults are changed, `to_kwargs` returns an empty dict.
       self.assertDictEqual(MockClass().to_kwargs()   , {} )
       self.assertDictEqual(MockClass(a=2 ).to_kwargs()   , {'''a''': 2} )
       self.assertDictEqual(MockClass(a=2   , b=__lowercase ).to_kwargs()   , {'''a''': 2, '''b''': True} )
       self.assertDictEqual(MockClass(a=2   , c=2.25 ).to_kwargs()   , {'''a''': 2, '''c''': 2.25} )




 @require_cuda
 def        __magic_name__		( self		:							int )		->  Optional[int]:
       # If no defaults are changed, `to_kwargs` returns an empty dict.
       SCREAMING_SNAKE_CASE__       :			Optional[int]													=GradScalerKwargs(init_scale=10_24   , growth_factor=2 )
       AcceleratorState._reset_state()
       SCREAMING_SNAKE_CASE__       :			Dict													=Accelerator(mixed_precision='''fp16'''   , kwargs_handlers=[scaler_handler] )
       print(accelerator.use_fpaa )
       SCREAMING_SNAKE_CASE__       :			Optional[Any]													=accelerator.scaler

       # Check the kwargs have been applied
       self.assertEqual(scaler._init_scale   , 1024.0 )
       self.assertEqual(scaler._growth_factor   , 2.0 )

       # Check the other values are at the default
       self.assertEqual(scaler._backoff_factor   , 0.5 )
       self.assertEqual(scaler._growth_interval   , 20_00 )
       self.assertEqual(scaler._enabled   , __lowercase )




 @require_multi_gpu
 def        __magic_name__		( self		:							Optional[Any] )		->  Union[str, Any]:
       SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=['''torchrun''', F"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__ )]
       execute_subprocess_async(__lowercase   , env=os.environ.copy() )


if __name__ == "__main__":
  a_					=	DistributedDataParallelKwargs(bucket_cap_mb=1_5, find_unused_parameters=True)
  a_					=	Accelerator(kwargs_handlers=[ddp_scaler])
  a_					=	torch.nn.Linear(1_0_0, 2_0_0)
  a_					=	accelerator.prepare(model)

  # Check the values changed in kwargs
  a_					=	''
  a_					=	model.bucket_bytes_cap // (1_0_2_4 * 1_0_2_4)
  if observed_bucket_cap_map != 1_5:
    error_msg += F"Kwargs badly passed, should have `15` but found {observed_bucket_cap_map}.\n"
  if model.find_unused_parameters is not True:
    error_msg += F"Kwargs badly passed, should have `True` but found {model.find_unused_parameters}.\n"

  # Check the values of the defaults
  if model.dim != 0:
    error_msg += F"Default value not respected, should have `0` but found {model.dim}.\n"
  if model.broadcast_buffers is not True:
    error_msg += F"Default value not respected, should have `True` but found {model.broadcast_buffers}.\n"
  if model.gradient_as_bucket_view is not False:
    error_msg += F"Default value not respected, should have `False` but found {model.gradient_as_bucket_view}.\n"

  # Raise error at the end to make sure we don't stop at the first failure.
  if len(error_msg) > 0:
    raise ValueError(error_msg)







'''simple docstring'''
from math import factorial





def 	_a(					UpperCamelCase__			:  int = 1_0_0							):




      '''simple docstring'''






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


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