"""simple docstring"""







from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding

class 						UpperCamelCase     (       lowercase		):
				UpperCAmelCase							: List[Any]       =						["""image_processor""", """tokenizer"""]
				UpperCAmelCase							: Optional[Any]       =						"""EfficientNetImageProcessor"""
				UpperCAmelCase							: Optional[Any]       =						("""BertTokenizer""", """BertTokenizerFast""")



				def __init__(self							: Optional[Any]      ,    _A							: Optional[Any]      ,    _A							: str)       ->      str:
					super().__init__(_A      ,    _A)



				def __call__(self							: Optional[Any]      ,    _A							: Dict=None      ,    _A							: Union[str, Any]=None      ,    _A							: str="max_length"      ,    _A							: List[Any]=64      ,    _A							: str=None      ,    **_A							: Optional[int])       ->      List[str]:
					if text is None and images is None:
						raise ValueError('You have to specify either text or images. Both cannot be none.')

					if text is not None:
						__snake_case     :				str 						=					self.tokenizer(
						    _A      ,    padding=_A      ,    max_length=_A      ,    return_tensors=_A      ,    **_A)

					if images is not None:
						__snake_case     :				Dict 						=					self.image_processor(_A      ,    return_tensors=_A      ,    **_A)

					if text is not None and images is not None:
						__snake_case     :				str 						=					image_features.pixel_values
						return encoding
					elif text is not None:
						return encoding
					else:
						return BatchEncoding(data=dict(**_A)      ,    tensor_type=_A)



				def    _lowercase	(self							: Optional[Any]      ,    *_A							: List[str]      ,    **_A							: Union[str, Any])       ->      Dict:
					return self.tokenizer.batch_decode(*_A      ,    **_A)



				def    _lowercase	(self							: Optional[Any]      ,    *_A							: Any      ,    **_A							: List[str])       ->      Union[str, Any]:
					return self.tokenizer.decode(*_A      ,    **_A)






				@property
				def    _lowercase	(self							: Dict)       ->      Union[str, Any]:
					__snake_case     :				Dict 						=					self.tokenizer.model_input_names
					__snake_case     :				Optional[Any] 						=					self.image_processor.model_input_names
					return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names))






"""simple docstring"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							int = 1_00    )				->     int:

	'''simple docstring'''





	__snake_case     :				Any 						=					1
	__snake_case     :				Tuple 						=					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())))





