






from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
	from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore


class        lowercase__       (     _UpperCAmelCase		):
	a_             =c_float

	@property
	def 						UpperCAmelCase					(							self    )->   int:







							'''simple docstring'''





							return sizeof(self.value    )





def     _a					(       UpperCamelCase_   :			int      ,				UpperCamelCase_   :			int      ,				UpperCamelCase_   :			int = 0				)	->				int:
						"""simple docstring"""







						if dimension <= 0:
												lowerCAmelCase__	 =  fixed_dimension

						dimension -= num_token_to_add
						return dimension


def     _a					(       UpperCamelCase_   :			int      ,				UpperCamelCase_   :			ParameterFormat				)	->				int:
						"""simple docstring"""







						return num_parameters * dtype.size





def     _a					(       UpperCamelCase_   :			str				)	->				Optional[Union["AutoTokenizer", "AutoFeatureExtractor", "AutoProcessor"]]:
						"""simple docstring"""







						from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

						try:
												return AutoProcessor.from_pretrained(UpperCamelCase_				)
						except (ValueError, OSError, KeyError):
												lowerCAmelCase__ ,							lowerCAmelCase__	 =  None, None
												try:
																		lowerCAmelCase__	 =  AutoTokenizer.from_pretrained(UpperCamelCase_				)
												except (OSError, KeyError):
																		pass
												try:
																		lowerCAmelCase__	 =  AutoFeatureExtractor.from_pretrained(UpperCamelCase_				)
												except (OSError, KeyError):
																		pass

												if tokenizer is not None and feature_extractor is not None:
																		raise ValueError(
																		    F"Couldn't auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor."				)
												elif tokenizer is None and feature_extractor is None:
																		return None
												elif tokenizer is not None:
																		return tokenizer
												else:
																		return feature_extractor














def     _a					(       UpperCamelCase_   :			int = 100				)	->				int:
						"""simple docstring"""







						lowerCAmelCase__	 =  1
						lowerCAmelCase__	 =  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())))






