


"""simple docstring"""
# Lint as: python3
import sys
from collections.abc import Mapping
from typing import TYPE_CHECKING, Dict, Optional

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.logging import get_logger
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter


if TYPE_CHECKING:
				import jax
				import jaxlib

__SCREAMING_SNAKE_CASE							:    Optional[Any]		=    get_logger()

__SCREAMING_SNAKE_CASE							:    Optional[dict]		=    None





class      __A     (TensorFormatter[Mapping, """jax.Array""", Mapping]):





							'''simple docstring'''

							def __init__(				self							:      int		,       UpperCAmelCase_							:      Dict=None		,       UpperCAmelCase_							:      List[str]=None		,       **UpperCAmelCase_							:      Tuple       )					->Optional[Any]:



														"""simple docstring"""



														super().__init__(features=UpperCAmelCase_       )
														import jax
														from jaxlib.xla_client import Device

														if isinstance(UpperCAmelCase_		,       UpperCAmelCase_       ):
																					raise ValueError(
																					    F"""Expected {device} to be a `str` not {type(UpperCAmelCase_       )}, as `jaxlib.xla_extension.Device` """
																					    """is not serializable neither with `pickle` nor with `dill`. Instead you can surround """
																					    """the device with `str()` to get its string identifier that will be internally mapped """
																					    """to the actual `jaxlib.xla_extension.Device`."""       )
														snake_case_           =		device if isinstance(UpperCAmelCase_		,       UpperCAmelCase_       ) else str(jax.devices()[0]       )
														# using global variable since `jaxlib.xla_extension.Device` is not serializable neither
														# with `pickle` nor with `dill`, so we need to use a global variable instead
														global DEVICE_MAPPING
														if DEVICE_MAPPING is None:
																					snake_case_           =		self._map_devices_to_str()
														if self.device not in list(DEVICE_MAPPING.keys()       ):
																					logger.warning(
																					    F"""Device with string identifier {self.device} not listed among the available """
																					    F"""devices: {list(DEVICE_MAPPING.keys()       )}, so falling back to the default """
																					    F"""device: {str(jax.devices()[0]       )}."""       )
																					snake_case_           =		str(jax.devices()[0]       )
														snake_case_           =		jnp_array_kwargs



							@staticmethod
							def 		lowerCAmelCase       (				)					->Dict[str, "jaxlib.xla_extension.Device"]:



														"""simple docstring"""



														import jax

														return {str(UpperCAmelCase_       ): device for device in jax.devices()}



							def 		lowerCAmelCase       (				self							:      Any		,       UpperCAmelCase_							:      List[str]       )					->str:



														"""simple docstring"""



														import jax
														import jax.numpy as jnp

														if isinstance(UpperCAmelCase_		,       UpperCAmelCase_       ) and column:
																					if all(
																					    isinstance(UpperCAmelCase_		,       jax.Array       ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column       ):
																												return jnp.stack(UpperCAmelCase_		,       axis=0       )
														return column



							def 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      List[Any]       )					->Optional[int]:



														"""simple docstring"""



														import jax
														import jax.numpy as jnp

														if isinstance(UpperCAmelCase_		,       (str, bytes, type(UpperCAmelCase_       ))       ):
																					return value
														elif isinstance(UpperCAmelCase_		,       (np.character, np.ndarray)       ) and np.issubdtype(value.dtype		,       np.character       ):
																					return value.tolist()

														snake_case_           =		{}

														if isinstance(UpperCAmelCase_		,       (np.number, np.ndarray)       ) and np.issubdtype(value.dtype		,       np.integer       ):
																					# the default int precision depends on the jax config
																					# see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision
																					if jax.config.jax_enable_xaa:
																												snake_case_           =		{"""dtype""": jnp.intaa}
																					else:
																												snake_case_           =		{"""dtype""": jnp.intaa}
														elif isinstance(UpperCAmelCase_		,       (np.number, np.ndarray)       ) and np.issubdtype(value.dtype		,       np.floating       ):
																					snake_case_           =		{"""dtype""": jnp.floataa}
														elif config.PIL_AVAILABLE and "PIL" in sys.modules:
																					import PIL.Image

																					if isinstance(UpperCAmelCase_		,       PIL.Image.Image       ):
																												snake_case_           =		np.asarray(UpperCAmelCase_       )

        # using global variable since `jaxlib.xla_extension.Device` is not serializable neither
        # with `pickle` nor with `dill`, so we need to use a global variable instead
														global DEVICE_MAPPING
														if DEVICE_MAPPING is None:
																					snake_case_           =		self._map_devices_to_str()

														with jax.default_device(DEVICE_MAPPING[self.device]       ):
																					# calling jnp.array on a np.ndarray does copy the data
																					# see https://github.com/google/jax/issues/4486
																					return jnp.array(UpperCAmelCase_		,       **{**default_dtype, **self.jnp_array_kwargs}       )



							def 		lowerCAmelCase       (				self							:      List[Any]		,       UpperCAmelCase_							:      Optional[Any]       )					->List[Any]:



														"""simple docstring"""



														import jax

														# support for torch, tf, jax etc.
														if config.TORCH_AVAILABLE and "torch" in sys.modules:
																					import torch

																					if isinstance(UpperCAmelCase_		,       torch.Tensor       ):
																												return self._tensorize(data_struct.detach().cpu().numpy()[()]       )
														if hasattr(UpperCAmelCase_		,       """__array__"""       ) and not isinstance(UpperCAmelCase_		,       jax.Array       ):
																					snake_case_           =		data_struct.__array__()
														# support for nested types like struct of list of struct
														if isinstance(UpperCAmelCase_		,       np.ndarray       ):
																					if data_struct.dtype == object:  # jax arrays cannot be instantied from an array of objects
																												return self._consolidate([self.recursive_tensorize(UpperCAmelCase_       ) for substruct in data_struct]       )
														elif isinstance(UpperCAmelCase_		,       (list, tuple)       ):
																					return self._consolidate([self.recursive_tensorize(UpperCAmelCase_       ) for substruct in data_struct]       )
														return self._tensorize(UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      List[str]		,       UpperCAmelCase_							:      dict       )					->int:



														"""simple docstring"""



														return map_nested(self._recursive_tensorize		,       UpperCAmelCase_		,       map_list=UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      Dict		,       UpperCAmelCase_							:      pa.Table       )					->Mapping:



														"""simple docstring"""



														snake_case_           =		self.numpy_arrow_extractor().extract_row(UpperCAmelCase_       )
														snake_case_           =		self.python_features_decoder.decode_row(UpperCAmelCase_       )
														return self.recursive_tensorize(UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      List[str]		,       UpperCAmelCase_							:      pa.Table       )					->"jax.Array":



														"""simple docstring"""



														snake_case_           =		self.numpy_arrow_extractor().extract_column(UpperCAmelCase_       )
														snake_case_           =		self.python_features_decoder.decode_column(UpperCAmelCase_		,       pa_table.column_names[0]       )
														snake_case_           =		self.recursive_tensorize(UpperCAmelCase_       )
														snake_case_           =		self._consolidate(UpperCAmelCase_       )
														return column



							def 		lowerCAmelCase       (				self							:      Optional[int]		,       UpperCAmelCase_							:      pa.Table       )					->Mapping:



														"""simple docstring"""



														snake_case_           =		self.numpy_arrow_extractor().extract_batch(UpperCAmelCase_       )
														snake_case_           =		self.python_features_decoder.decode_batch(UpperCAmelCase_       )
														snake_case_           =		self.recursive_tensorize(UpperCAmelCase_       )
														for column_name in batch:
																					snake_case_           =		self._consolidate(batch[column_name]       )
														return batch







"""simple docstring"""
from math import factorial







def 						_a				(      _SCREAMING_SNAKE_CASE = 100				)    ->				int:
							return sum(int(_SCREAMING_SNAKE_CASE				) for x in str(factorial(_SCREAMING_SNAKE_CASE				)				)				)


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



