
from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import pyarrow as pa


if TYPE_CHECKING:
     from .features import FeatureType




@dataclass
class 					_SCREAMING_SNAKE_CASE  :
      _A						:		List[str]
      _A						:		Optional[str]    	=     None
      # Automatically constructed
      _A						:		ClassVar[str]    	=     "dict"
      _A						:		ClassVar[Any]    	=     None
      _A						:		str    	=     field(default='Translation'       ,					init=__UpperCamelCase       ,					repr=__UpperCamelCase )
      def __call__(			self ):
          return pa.struct({lang: pa.string() for lang in sorted(self.languages )} )



      def A_			(			self ):
          from .features import Value

          return {k: Value("string" ) for k in sorted(self.languages )}





@dataclass
class 					_SCREAMING_SNAKE_CASE  :
      _A						:		Optional[List]    	=     None
      _A						:		Optional[int]    	=     None
      _A						:		Optional[str]    	=     None
      # Automatically constructed
      _A						:		ClassVar[str]    	=     "dict"
      _A						:		ClassVar[Any]    	=     None
      _A						:		str    	=     field(default='TranslationVariableLanguages'       ,					init=__UpperCamelCase       ,					repr=__UpperCamelCase )
      def A_			(			self ):
          snake_case__						=				sorted(set(self.languages ) ) if self.languages else None
          snake_case__						=				len(self.languages ) if self.languages else None
      def __call__(			self ):
          return pa.struct({"language": pa.list_(pa.string() ), "translation": pa.list_(pa.string() )} )
      def A_			(			self		,	lowerCamelCase ):
          snake_case__						=				set(self.languages )
          if self.languages and set(lowerCamelCase ) - lang_set:
              raise ValueError(
                  F"""Some languages in example ({", ".join(sorted(set(lowerCamelCase ) - lang_set ) )}) are not in valid set ({", ".join(lowerCamelCase )}).""" )

          # Convert dictionary into tuples, splitting out cases where there are
          # multiple translations for a single language.
          snake_case__						=				[]
          for lang, text in translation_dict.items():
              if isinstance(lowerCamelCase		,	lowerCamelCase ):
                  translation_tuples.append((lang, text) )
              else:
                  translation_tuples.extend([(lang, el) for el in text] )

        # Ensure translations are in ascending order by language code.
          snake_case__						,					snake_case__						=				zip(*sorted(lowerCamelCase ) )

          return {"language": languages, "translation": translations}



      def A_			(			self ):
          from .features import Sequence, Value

          return {
              "language": Sequence(Value("string" ) ),
              "translation": Sequence(Value("string" ) ),
          }





from math import factorial





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase = 100							):
    return sum(int(__lowerCAmelCase							) for x in str(factorial(__lowerCAmelCase							)							)							)


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



