"""simple docstring"""







import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


_a	:	int=					namedtuple("ExampleNamedTuple", "a b c")

class 						UpperCamelCase     (       unittest.TestCase		):



				def    _lowercase	(self							: Union[str, Any])       ->      str:
					__snake_case     :				Dict 						=					torch.randn(5      ,    2)
					__snake_case     :				List[Any] 						=					torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')

					__snake_case     :				Optional[Any] 						=					send_to_device(_A      ,    _A)
					self.assertTrue(torch.equal(resulta.cpu()      ,    _A))

					__snake_case     :				List[str] 						=					send_to_device((tensor, [tensor, tensor], 1)      ,    _A)
					self.assertIsInstance(_A      ,    _A)
					self.assertTrue(torch.equal(resulta[0].cpu()      ,    _A))
					self.assertIsInstance(resulta[1]      ,    _A)
					self.assertTrue(torch.equal(resulta[1][0].cpu()      ,    _A))
					self.assertTrue(torch.equal(resulta[1][1].cpu()      ,    _A))
					self.assertEqual(resulta[2]      ,    1)

					__snake_case     :				List[Any] 						=					send_to_device({'a': tensor, 'b': [tensor, tensor], 'c': 1}      ,    _A)
					self.assertIsInstance(_A      ,    _A)
					self.assertTrue(torch.equal(resulta['a'].cpu()      ,    _A))
					self.assertIsInstance(resulta['b']      ,    _A)
					self.assertTrue(torch.equal(resulta['b'][0].cpu()      ,    _A))
					self.assertTrue(torch.equal(resulta['b'][1].cpu()      ,    _A))
					self.assertEqual(resulta['c']      ,    1)

					__snake_case     :				Any 						=					send_to_device(ExampleNamedTuple(a=_A      ,    b=[tensor, tensor]      ,    c=1)      ,    _A)
					self.assertIsInstance(_A      ,    _A)
					self.assertTrue(torch.equal(resulta.a.cpu()      ,    _A))
					self.assertIsInstance(resulta.b      ,    _A)
					self.assertTrue(torch.equal(resulta.b[0].cpu()      ,    _A))
					self.assertTrue(torch.equal(resulta.b[1].cpu()      ,    _A))
					self.assertEqual(resulta.c      ,    1)

					__snake_case     :				Union[str, Any] 						=					send_to_device(UserDict({'a': tensor, 'b': [tensor, tensor], 'c': 1})      ,    _A)
					self.assertIsInstance(_A      ,    _A)
					self.assertTrue(torch.equal(resulta['a'].cpu()      ,    _A))
					self.assertIsInstance(resulta['b']      ,    _A)
					self.assertTrue(torch.equal(resulta['b'][0].cpu()      ,    _A))
					self.assertTrue(torch.equal(resulta['b'][1].cpu()      ,    _A))
					self.assertEqual(resulta['c']      ,    1)



				def    _lowercase	(self							: Union[str, Any])       ->      Optional[Any]:
					with self.assertRaises(_A) as cm:
						__snake_case     :				Dict 						=					recursively_apply(torch.tensor      ,    (torch.tensor(1), 1)      ,    error_on_other_type=_A)
					self.assertEqual(
					    str(cm.exception)      ,    'Unsupported types (<class \'int\'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed.'      ,    )



				def    _lowercase	(self							: List[Any])       ->      Tuple:
					__snake_case     :				Optional[Any] 						=					torch.tensor([1, 2, 3, 4, 5])
					self.assertEqual(listify(_A)      ,    [1, 2, 3, 4, 5])

					__snake_case     :				Optional[Any] 						=					torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
					self.assertEqual(listify(_A)      ,    [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

					__snake_case     :				str 						=					torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]])
					self.assertEqual(
					    listify(_A)      ,    [[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]])



				def    _lowercase	(self							: List[str])       ->      Any:
					with patch_environment(aa=1      ,    BB=2):
						self.assertEqual(os.environ.get('AA')      ,    '1')
						self.assertEqual(os.environ.get('BB')      ,    '2')

					self.assertNotIn('AA'      ,    os.environ)
					self.assertNotIn('BB'      ,    os.environ)



				def    _lowercase	(self							: Dict)       ->      int:
					__snake_case     :				Any 						=					RegressionModel()
					__snake_case     :				str 						=					model.forward
					__snake_case     :				List[Any] 						=					convert_outputs_to_fpaa(model.forward)
					__snake_case     :				Optional[int] 						=					extract_model_from_parallel(_A      ,    keep_fpaa_wrapper=_A)
					__snake_case     :				Tuple 						=					pickle.dumps(_A)



				@require_cuda
				def    _lowercase	(self							: str)       ->      List[Any]:
					__snake_case     :				Any 						=					RegressionModel()
					__snake_case     :				Dict 						=					model.forward
					__snake_case     :				Any 						=					torch.cuda.amp.autocast(dtype=torch.floataa)(model.forward)
					__snake_case     :				Tuple 						=					convert_outputs_to_fpaa(model.forward)
					__snake_case     :				Tuple 						=					extract_model_from_parallel(_A      ,    keep_fpaa_wrapper=_A)
					__snake_case     :				List[str] 						=					pickle.dumps(_A)



				@require_cuda
				@require_torch_min_version(version='2.0')
				def    _lowercase	(self							: Union[str, Any])       ->      Optional[int]:
					__snake_case     :				str 						=					RegressionModel()
					__snake_case     :				Tuple 						=					model.forward
					__snake_case     :				str 						=					torch.cuda.amp.autocast(dtype=torch.floataa)(model.forward)
					__snake_case     :				List[Any] 						=					convert_outputs_to_fpaa(model.forward)
					__snake_case     :				Any 						=					torch.compile(model.forward      ,    backend='inductor')
					__snake_case     :				List[Any] 						=					torch.randn(4      ,    10).cuda()
					__snake_case     :				Dict 						=					model(_A)



				def    _lowercase	(self							: int)       ->      Optional[Any]:
					__snake_case     :				Union[str, Any] 						=					RegressionModel()
					# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
					__snake_case     :				Optional[int] 						=					torch.nn.parallel.DataParallel(_A)
					__snake_case     :				Any 						=					extract_model_from_parallel(_A)

					self.assertEqual(_A      ,    _A)



				@require_torch_min_version(version='2.0')
				def    _lowercase	(self							: Optional[Any])       ->      int:
					__snake_case     :				Optional[Any] 						=					RegressionModel()
					__snake_case     :				Any 						=					torch.compile(_A)

					# could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
					__snake_case     :				Optional[Any] 						=					torch.nn.parallel.DataParallel(_A)
					__snake_case     :				Union[str, Any] 						=					torch.compile(_A)
					__snake_case     :				Any 						=					extract_model_from_parallel(_A)

					self.assertEqual(compiled_model._orig_mod      ,    compiled_model_unwrapped._orig_mod)






				def    _lowercase	(self							: List[str])       ->      Tuple:
					self.assertEqual(find_device([1, 'a', torch.tensor([1, 2, 3])])      ,    torch.device('cpu'))
					self.assertEqual(find_device({'a': 1, 'b': torch.tensor([1, 2, 3])})      ,    torch.device('cpu'))
					self.assertIsNone(find_device([1, 'a']))






"""simple docstring"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							int = 1_00    )				->     int:

	'''simple docstring'''





	__snake_case     :				Any 						=					1
	__snake_case     :				Tuple 						=					0
	for i in range(1     ,				num + 1    ):
		fact *= i

	for j in str(UpperCAmelCase_    ):
		result += int(UpperCAmelCase_    )

	return result


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





