


"""simple docstring"""






import os
import sys
import warnings
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen
from ..table import array_cast
from ..utils.file_utils import is_local_path
from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
	import PIL.Image

	from .features import FeatureType


_lowerCamelCase     =  None
_lowerCamelCase     =  '<' if sys.byteorder == 'little' else '>'
# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
_lowerCamelCase     =  [
    np.dtype('|b1'),
    np.dtype('|u1'),
    np.dtype('<u2'),
    np.dtype('>u2'),
    np.dtype('<i2'),
    np.dtype('>i2'),
    np.dtype('<u4'),
    np.dtype('>u4'),
    np.dtype('<i4'),
    np.dtype('>i4'),
    np.dtype('<f4'),
    np.dtype('>f4'),
    np.dtype('<f8'),
    np.dtype('>f8'),
]


@dataclass
class 			lowerCamelCase_		:





				"""simple docstring"""







				_lowerCAmelCase      :      bool      							=					True
				_lowerCAmelCase      :      Optional[str]      							=					None
				# Automatically constructed
				_lowerCAmelCase      :      ClassVar[str]      							=					"PIL.Image.Image"
				_lowerCAmelCase      :      ClassVar[Any]      							=					pa.struct({"bytes": pa.binary(), "path": pa.string()}   )
				_lowerCAmelCase      :      str      							=					field(default="Image"       ,  init=lowercase       ,  repr=lowercase   )



				def __call__(						self     ):
								return self.pa_type



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								if config.PIL_AVAILABLE:
												import PIL.Image
								else:
												raise ImportError("To support encoding images, please install 'Pillow'."     )

								if isinstance(UpperCAmelCase__       ,		UpperCAmelCase__     ):
												SCREAMING_SNAKE_CASE__     							=				np.array(UpperCAmelCase__     )

								if isinstance(UpperCAmelCase__       ,		UpperCAmelCase__     ):
												return {"path": value, "bytes": None}
								elif isinstance(UpperCAmelCase__       ,		UpperCAmelCase__     ):
												return {"path": None, "bytes": value}
								elif isinstance(UpperCAmelCase__       ,		np.ndarray     ):
												# convert the image array to PNG/TIFF bytes
												return encode_np_array(UpperCAmelCase__     )
								elif isinstance(UpperCAmelCase__       ,		PIL.Image.Image     ):
												# convert the PIL image to bytes (default format is PNG/TIFF)
												return encode_pil_image(UpperCAmelCase__     )
								elif value.get("path"     ) is not None and os.path.isfile(value["path"]     ):
												# we set "bytes": None to not duplicate the data if they're already available locally
												return {"bytes": None, "path": value.get("path"     )}
								elif value.get("bytes"     ) is not None or value.get("path"     ) is not None:
												# store the image bytes, and path is used to infer the image format using the file extension
												return {"bytes": value.get("bytes"     ), "path": value.get("path"     )}
								else:
												raise ValueError(
												    f'''An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.'''     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__=None     ):
								if not self.decode:
												raise RuntimeError("Decoding is disabled for this feature. Please use Image(decode=True) instead."     )

								if config.PIL_AVAILABLE:
												import PIL.Image
								else:
												raise ImportError("To support decoding images, please install 'Pillow'."     )

								if token_per_repo_id is None:
												SCREAMING_SNAKE_CASE__     							=				{}

								SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				value["path"], value["bytes"]
								if bytes_ is None:
												if path is None:
																raise ValueError(f'''An image should have one of \'path\' or \'bytes\' but both are None in {value}.'''     )
												else:
																if is_local_path(UpperCAmelCase__     ):
																				SCREAMING_SNAKE_CASE__     							=				PIL.Image.open(UpperCAmelCase__     )
																else:
																				SCREAMING_SNAKE_CASE__     							=				path.split("::"     )[-1]
																				try:
																								SCREAMING_SNAKE_CASE__     							=				string_to_dict(UpperCAmelCase__       ,		config.HUB_DATASETS_URL     )["repo_id"]
																								SCREAMING_SNAKE_CASE__     							=				token_per_repo_id.get(UpperCAmelCase__     )
																				except ValueError:
																								SCREAMING_SNAKE_CASE__     							=				None
																				with xopen(UpperCAmelCase__       ,		"rb"       ,		use_auth_token=UpperCAmelCase__     ) as f:
																								SCREAMING_SNAKE_CASE__     							=				BytesIO(f.read()     )
																				SCREAMING_SNAKE_CASE__     							=				PIL.Image.open(bytes_     )
								else:
												SCREAMING_SNAKE_CASE__     							=				PIL.Image.open(BytesIO(bytes_     )     )
								image.load()  # to avoid "Too many open files" errors
								return image



				def   lowerCAmelCase__		(						self     ):
								from .features import Value

								return (
								    self
								    if self.decode
								    else {
								        "bytes": Value("binary"     ),
								        "path": Value("string"     ),
								    }
								)



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								if pa.types.is_string(storage.type     ):
												SCREAMING_SNAKE_CASE__     							=				pa.array([None] * len(UpperCAmelCase__     )       ,		type=pa.binary()     )
												SCREAMING_SNAKE_CASE__     							=				pa.StructArray.from_arrays([bytes_array, storage]       ,		["bytes", "path"]       ,		mask=storage.is_null()     )
								elif pa.types.is_binary(storage.type     ):
												SCREAMING_SNAKE_CASE__     							=				pa.array([None] * len(UpperCAmelCase__     )       ,		type=pa.string()     )
												SCREAMING_SNAKE_CASE__     							=				pa.StructArray.from_arrays([storage, path_array]       ,		["bytes", "path"]       ,		mask=storage.is_null()     )
								elif pa.types.is_struct(storage.type     ):
												if storage.type.get_field_index("bytes"     ) >= 0:
																SCREAMING_SNAKE_CASE__     							=				storage.field("bytes"     )
												else:
																SCREAMING_SNAKE_CASE__     							=				pa.array([None] * len(UpperCAmelCase__     )       ,		type=pa.binary()     )
												if storage.type.get_field_index("path"     ) >= 0:
																SCREAMING_SNAKE_CASE__     							=				storage.field("path"     )
												else:
																SCREAMING_SNAKE_CASE__     							=				pa.array([None] * len(UpperCAmelCase__     )       ,		type=pa.string()     )
												SCREAMING_SNAKE_CASE__     							=				pa.StructArray.from_arrays([bytes_array, path_array]       ,		["bytes", "path"]       ,		mask=storage.is_null()     )
								elif pa.types.is_list(storage.type     ):
												SCREAMING_SNAKE_CASE__     							=				pa.array(
												    [encode_np_array(np.array(UpperCAmelCase__     )     )["bytes"] if arr is not None else None for arr in storage.to_pylist()]       ,		type=pa.binary()       ,		)
												SCREAMING_SNAKE_CASE__     							=				pa.array([None] * len(UpperCAmelCase__     )       ,		type=pa.string()     )
												SCREAMING_SNAKE_CASE__     							=				pa.StructArray.from_arrays(
												    [bytes_array, path_array]       ,		["bytes", "path"]       ,		mask=bytes_array.is_null()     )
								return array_cast(UpperCAmelCase__       ,		self.pa_type     )






				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):

								@no_op_if_value_is_null
								def path_to_bytes(UpperCAmelCase__     ):
												with xopen(UpperCAmelCase__       ,		"rb"     ) as f:
																SCREAMING_SNAKE_CASE__     							=				f.read()
												return bytes_

								SCREAMING_SNAKE_CASE__     							=				pa.array(
								    [
								        (path_to_bytes(x["path"]     ) if x["bytes"] is None else x["bytes"]) if x is not None else None
								        for x in storage.to_pylist()
								    ]       ,		type=pa.binary()       ,		)
								SCREAMING_SNAKE_CASE__     							=				pa.array(
								    [os.path.basename(UpperCAmelCase__     ) if path is not None else None for path in storage.field("path"     ).to_pylist()]       ,		type=pa.string()       ,		)
								SCREAMING_SNAKE_CASE__     							=				pa.StructArray.from_arrays([bytes_array, path_array]       ,		["bytes", "path"]       ,		mask=bytes_array.is_null()     )
								return array_cast(UpperCAmelCase__       ,		self.pa_type     )


def __lowercase     (      ):
				if config.PIL_AVAILABLE:
								import PIL.Image
				else:
								raise ImportError("To support encoding images, please install 'Pillow'."  )

				global _IMAGE_COMPRESSION_FORMATS
				if _IMAGE_COMPRESSION_FORMATS is None:
								PIL.Image.init()
								SCREAMING_SNAKE_CASE__     							=				list(set(PIL.Image.OPEN.keys()  ) & set(PIL.Image.SAVE.keys()  )  )
				return _IMAGE_COMPRESSION_FORMATS


def __lowercase     (      lowerCamelCase_  :      "PIL.Image.Image"  ):
				SCREAMING_SNAKE_CASE__     							=				BytesIO()
				if image.format in list_image_compression_formats():
								SCREAMING_SNAKE_CASE__     							=				image.format
				else:
								SCREAMING_SNAKE_CASE__     							=				"PNG" if image.mode in ["1", "L", "LA", "RGB", "RGBA"] else "TIFF"
				image.save(lowerCamelCase_						,					format=lowerCamelCase_  )
				return buffer.getvalue()


def __lowercase     (      lowerCamelCase_  :      "PIL.Image.Image"  ):
				if hasattr(lowerCamelCase_						,					"filename"  ) and image.filename != "":
								return {"path": image.filename, "bytes": None}
				else:
								return {"path": None, "bytes": image_to_bytes(lowerCamelCase_  )}


def __lowercase     (      lowerCamelCase_  :      np.ndarray  ):
				if config.PIL_AVAILABLE:
								import PIL.Image
				else:
								raise ImportError("To support encoding images, please install 'Pillow'."  )

				SCREAMING_SNAKE_CASE__     							=				array.dtype
				SCREAMING_SNAKE_CASE__     							=				dtype.byteorder if dtype.byteorder != "=" else _NATIVE_BYTEORDER
				SCREAMING_SNAKE_CASE__     							=				dtype.kind
				SCREAMING_SNAKE_CASE__     							=				dtype.itemsize

				SCREAMING_SNAKE_CASE__     							=				None

				# Multi-channel array case (only np.dtype("|u1") is allowed)
				if array.shape[2:]:
								SCREAMING_SNAKE_CASE__     							=				np.dtype("|u1"  )
								if dtype_kind not in ["u", "i"]:
												raise TypeError(
												    F'''Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.'''  )
								if dtype is not dest_dtype:
												warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''''  )
    # Exact match
				elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
								SCREAMING_SNAKE_CASE__     							=				dtype
				else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
								while dtype_itemsize >= 1:
												SCREAMING_SNAKE_CASE__     							=				dtype_byteorder + dtype_kind + str(lowerCamelCase_  )
												SCREAMING_SNAKE_CASE__     							=				np.dtype(lowerCamelCase_  )
												if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES:
																warnings.warn(F'''Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''''  )
																break
												else:
																dtype_itemsize //= 2

				if dest_dtype is None:
								raise TypeError(
								    F'''Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}'''  )
				SCREAMING_SNAKE_CASE__     							=				PIL.Image.fromarray(array.astype(lowerCamelCase_  )  )
				return {"path": None, "bytes": image_to_bytes(lowerCamelCase_  )}


def __lowercase     (      lowerCamelCase_  :      Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]]  ):
				if config.PIL_AVAILABLE:
								import PIL.Image
				else:
								raise ImportError("To support encoding images, please install 'Pillow'."  )

				if objs:
								SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				first_non_null_value(lowerCamelCase_  )
								if isinstance(lowerCamelCase_						,					lowerCamelCase_  ):
												return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
								if isinstance(lowerCamelCase_						,					np.ndarray  ):
												SCREAMING_SNAKE_CASE__     							=				no_op_if_value_is_null(lowerCamelCase_  )
												return [obj_to_image_dict_func(lowerCamelCase_  ) for obj in objs]
								elif isinstance(lowerCamelCase_						,					PIL.Image.Image  ):
												SCREAMING_SNAKE_CASE__     							=				no_op_if_value_is_null(lowerCamelCase_  )
												return [obj_to_image_dict_func(lowerCamelCase_  ) for obj in objs]
								else:
												return objs
				else:
								return objs




"""simple docstring"""






from math import factorial


def __lowercase     (      lowerCamelCase_  :      int = 100  ):
				return sum(int(lowerCamelCase_  ) for x in str(factorial(lowerCamelCase_  )  )  )


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