

import os
from typing import Optional

import fsspec
from fsspec.archive import AbstractArchiveFileSystem
from fsspec.utils import DEFAULT_BLOCK_SIZE

class 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       ''
			__lowerCamelCase        =       (
			    None  # protocol passed in prefix to the url. ex: "gzip", for gzip://file.txt::http://foo.bar/file.txt.gz
			)
			__lowerCamelCase        =       None  # compression type in fsspec. ex: "gzip"
			__lowerCamelCase        =       None  # extension of the filename to strip. ex: "".gz" to get file.txt from file.txt.gz


			def __init__(    self      ,      lowercase = ""      ,      lowercase = None      ,      lowercase = None      ,      **lowercase       )  ->						Any:
							'''simple docstring'''






							super().__init__(self      ,      **lowercase       )
							# always open as "rb" since fsspec can then use the TextIOWrapper to make it work for "r" mode
							A__        =			fsspec.open(
							    lowercase      ,      mode="rb"      ,      protocol=lowercase      ,      compression=self.compression      ,      client_kwargs={
							        "requote_redirect_url": False,  # see https://github.com/huggingface/datasets/pull/5459
							        "trust_env": True,  # Enable reading proxy env variables.
							        **(target_options or {}).pop("client_kwargs"      ,      {}       ),  # To avoid issues if it was already passed.
							    }      ,      **(target_options or {})      ,      )
							A__        =			os.path.basename(self.file.path.split("::"       )[0]       )
							A__        =			(
							    self.compressed_name[: self.compressed_name.rindex("."       )]
							    if "." in self.compressed_name
							    else self.compressed_name
							)
							A__        =			None


			@classmethod
			def      UpperCamelCase		(    cls      ,      lowercase       )  ->						Tuple:
							'''simple docstring'''






							return super()._strip_protocol(lowercase       ).lstrip("/"       )


			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							if self.dir_cache is None:
											A__        =			{**self.file.fs.info(self.file.path       ), "name": self.uncompressed_name}
											A__        =			{f["name"]: f}


			def      UpperCamelCase		(    self      ,      lowercase       )  ->						Tuple:
							'''simple docstring'''






							return self.file.open().read()


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase = "rb"      ,      lowercase=None      ,      lowercase=True      ,      lowercase=None      ,      **lowercase      ,      )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			self._strip_protocol(lowercase       )
							if mode != "rb":
											raise ValueError(F'Tried to read with mode {mode} on file {self.file.path} opened with mode \'rb\''       )
							return self.file.open()

class 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       'bz2'
			__lowerCamelCase        =       'bz2'
			__lowerCamelCase        =       '.bz2'

class 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       'gzip'
			__lowerCamelCase        =       'gzip'
			__lowerCamelCase        =       '.gz'

class 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       'lz4'
			__lowerCamelCase        =       'lz4'
			__lowerCamelCase        =       '.lz4'

class 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       'xz'
			__lowerCamelCase        =       'xz'
			__lowerCamelCase        =       '.xz'

class 					a__						(					snake_case			):
			"""simple docstring"""







			__lowerCamelCase        =       'zstd'
			__lowerCamelCase        =       'zstd'
			__lowerCamelCase        =       '.zst'


			def __init__(    self      ,      lowercase      ,      lowercase = "rb"      ,      lowercase = None      ,      lowercase = None      ,      lowercase = DEFAULT_BLOCK_SIZE      ,      **lowercase      ,      )  ->						List[str]:
							'''simple docstring'''






							super().__init__(
							    fo=lowercase      ,      mode=lowercase      ,      target_protocol=lowercase      ,      target_options=lowercase      ,      block_size=lowercase      ,      **lowercase      ,      )
							# We need to wrap the zstd decompressor to avoid this error in fsspec==2021.7.0 and zstandard==0.15.2:
							#
							# File "/Users/user/.virtualenvs/hf-datasets/lib/python3.7/site-packages/fsspec/core.py", line 145, in open
							#     out.close = close
							# AttributeError: 'zstd.ZstdDecompressionReader' object attribute 'close' is read-only
							#
							# see https://github.com/intake/filesystem_spec/issues/725
							A__        =			self.file.__enter__

							class 					a__						:
										"""simple docstring"""







										def __init__(    self      ,      lowercase       )  ->						List[Any]:
														'''simple docstring'''






														A__        =			file_


										def __enter__(    self       )  ->						List[str]:
														'''simple docstring'''






														self._file.__enter__()
														return self


										def __exit__(    self      ,      *lowercase      ,      **lowercase       )  ->						Union[str, Any]:
														'''simple docstring'''






														self._file.__exit__(*lowercase      ,      **lowercase       )


										def __iter__(    self       )  ->						Union[str, Any]:
														'''simple docstring'''






														return iter(self._file       )


										def      UpperCamelCase		(    self       )  ->						List[str]:
														'''simple docstring'''






														return next(self._file       )


										def __getattr__(    self      ,      lowercase       )  ->						Union[str, Any]:
														'''simple docstring'''






														return getattr(self._file      ,      lowercase       )

							def fixed_enter(*lowercase      ,      **lowercase       ):
											return WrappedFile(_enter(*lowercase      ,      **lowercase       )       )

							A__        =			fixed_enter


from math import factorial



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int = 1_0_0      )			->      int:




				'''simple docstring'''





				return sum(map(SCREAMING_SNAKE_CASE_	,       str(factorial(SCREAMING_SNAKE_CASE_      )      )      )      )


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

