"""simple docstring"""







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_a	:	str=					logging.get_logger(__name__)

_a	:	Optional[Any]=					{
    "facebook/sam-vit-huge": "https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json",
    "facebook/sam-vit-large": "https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json",
    "facebook/sam-vit-base": "https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json",
}

class 						UpperCamelCase     (       lowercase		):



				def __init__(self							: Optional[int]      ,    _A							: str=2_56      ,    _A							: Any=10_24      ,    _A							: List[str]=16      ,    _A							: Union[str, Any]=16      ,    _A							: List[str]=4      ,    _A							: int="gelu"      ,    _A							: Dict=1E-6      ,    **_A							: Union[str, Any]      ,    )       ->      str:
					super().__init__(**_A)
					__snake_case     :				List[Any] 						=					hidden_size
					__snake_case     :				List[str] 						=					image_size
					__snake_case     :				str 						=					patch_size
					__snake_case     :				Dict 						=					image_size // patch_size
					__snake_case     :				str 						=					mask_input_channels
					__snake_case     :				str 						=					num_point_embeddings
					__snake_case     :				List[Any] 						=					hidden_act
					__snake_case     :				List[Any] 						=					layer_norm_eps







class 						UpperCamelCase     (       lowercase		):



				def __init__(self							: List[Any]      ,    _A							: Any=2_56      ,    _A							: Optional[int]="relu"      ,    _A							: List[str]=20_48      ,    _A							: Optional[Any]=2      ,    _A							: Any=8      ,    _A							: Dict=2      ,    _A							: List[str]=3      ,    _A							: Optional[Any]=3      ,    _A							: Optional[int]=2_56      ,    _A							: List[Any]=1E-6      ,    **_A							: Tuple      ,    )       ->      int:
					super().__init__(**_A)
					__snake_case     :				Any 						=					hidden_size
					__snake_case     :				int 						=					hidden_act
					__snake_case     :				Optional[Any] 						=					mlp_dim
					__snake_case     :				Dict 						=					num_hidden_layers
					__snake_case     :				List[Any] 						=					num_attention_heads
					__snake_case     :				List[str] 						=					attention_downsample_rate
					__snake_case     :				Optional[int] 						=					num_multimask_outputs
					__snake_case     :				List[str] 						=					iou_head_depth
					__snake_case     :				Dict 						=					iou_head_hidden_dim
					__snake_case     :				List[Any] 						=					layer_norm_eps







class 						UpperCamelCase     (       lowercase		):



				def __init__(self							: str      ,    _A							: Any=7_68      ,    _A							: int=2_56      ,    _A							: List[str]=12      ,    _A							: Union[str, Any]=12      ,    _A							: Any=3      ,    _A							: Any=10_24      ,    _A							: str=16      ,    _A							: Union[str, Any]="gelu"      ,    _A							: Tuple=1E-06      ,    _A							: Optional[Any]=0.0      ,    _A							: Union[str, Any]=1E-10      ,    _A							: str=True      ,    _A							: Dict=4.0      ,    _A							: str=True      ,    _A							: str=True      ,    _A							: Any=14      ,    _A							: Union[str, Any]=[2, 5, 8, 11]      ,    _A							: Optional[int]=1_28      ,    _A							: List[str]=None      ,    **_A							: List[str]      ,    )       ->      Dict:
					super().__init__(**_A)

					__snake_case     :				Optional[Any] 						=					hidden_size
					__snake_case     :				Tuple 						=					output_channels
					__snake_case     :				Optional[Any] 						=					num_hidden_layers
					__snake_case     :				Union[str, Any] 						=					num_attention_heads
					__snake_case     :				Optional[int] 						=					num_channels
					__snake_case     :				List[Any] 						=					image_size
					__snake_case     :				Tuple 						=					patch_size
					__snake_case     :				str 						=					hidden_act
					__snake_case     :				Optional[int] 						=					layer_norm_eps
					__snake_case     :				int 						=					attention_dropout
					__snake_case     :				Optional[Any] 						=					initializer_range
					__snake_case     :				Tuple 						=					qkv_bias
					__snake_case     :				str 						=					mlp_ratio
					__snake_case     :				Any 						=					use_abs_pos
					__snake_case     :				Optional[int] 						=					use_rel_pos
					__snake_case     :				List[Any] 						=					window_size
					__snake_case     :				Optional[Any] 						=					global_attn_indexes
					__snake_case     :				List[str] 						=					num_pos_feats
					__snake_case     :				Optional[Any] 						=					int(hidden_size * mlp_ratio) if mlp_dim is None else mlp_dim







class 						UpperCamelCase     (       lowercase		):
				UpperCAmelCase							: Any       =						"""sam"""
				UpperCAmelCase							: List[Any]       =						True



				def __init__(self							: Optional[int]      ,    _A							: Tuple=None      ,    _A							: Optional[Any]=None      ,    _A							: Any=None      ,    _A							: Tuple=0.02      ,    **_A							: Any      ,    )       ->      Tuple:
					super().__init__(**_A)
					__snake_case     :				Tuple 						=					vision_config if vision_config is not None else {}
					__snake_case     :				Dict 						=					prompt_encoder_config if prompt_encoder_config is not None else {}
					__snake_case     :				str 						=					mask_decoder_config if mask_decoder_config is not None else {}

					if isinstance(_A      ,    _A):
						__snake_case     :				Optional[int] 						=					vision_config.to_dict()
					if isinstance(_A      ,    _A):
						__snake_case     :				Union[str, Any] 						=					prompt_encoder_config.to_dict()
					if isinstance(_A      ,    _A):
						__snake_case     :				Optional[Any] 						=					mask_decoder_config.to_dict()

					__snake_case     :				Any 						=					SamVisionConfig(**_A)
					__snake_case     :				Optional[int] 						=					SamPromptEncoderConfig(**_A)
					__snake_case     :				List[Any] 						=					SamMaskDecoderConfig(**_A)
					__snake_case     :				str 						=					initializer_range






				def    _lowercase	(self							: Tuple)       ->      Tuple:
					__snake_case     :				int 						=					copy.deepcopy(self.__dict__)
					__snake_case     :				List[Any] 						=					self.vision_config.to_dict()
					__snake_case     :				Dict 						=					self.prompt_encoder_config.to_dict()
					__snake_case     :				Any 						=					self.mask_decoder_config.to_dict()
					__snake_case     :				Optional[int] 						=					self.__class__.model_type
					return output






"""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())))





