


"""simple docstring"""
import copy
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


__SCREAMING_SNAKE_CASE							:    Dict		=    logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE							:    Tuple		=    {
    'microsoft/conditional-detr-resnet-50': (
        'https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json'
    ),
}



class      __A     (__A):





							'''simple docstring'''

							__lowercase:		Any							      =    """conditional_detr"""
							__lowercase:		Optional[Any]							      =    ["""past_key_values"""]
							__lowercase:		Dict							      =    {
							    """hidden_size""": """d_model""",
							    """num_attention_heads""": """encoder_attention_heads""",
							}



							def __init__(				self							:      Tuple		,       UpperCAmelCase_							:      int=True		,       UpperCAmelCase_							:      Dict=None		,       UpperCAmelCase_							:      List[str]=3		,       UpperCAmelCase_							:      Any=300		,       UpperCAmelCase_							:      Any=6		,       UpperCAmelCase_							:      Dict=2_048		,       UpperCAmelCase_							:      int=8		,       UpperCAmelCase_							:      str=6		,       UpperCAmelCase_							:      List[Any]=2_048		,       UpperCAmelCase_							:      Optional[Any]=8		,       UpperCAmelCase_							:      Dict=0.0		,       UpperCAmelCase_							:      int=0.0		,       UpperCAmelCase_							:      Optional[int]=True		,       UpperCAmelCase_							:      Optional[Any]="relu"		,       UpperCAmelCase_							:      str=256		,       UpperCAmelCase_							:      List[Any]=0.1		,       UpperCAmelCase_							:      Optional[Any]=0.0		,       UpperCAmelCase_							:      str=0.0		,       UpperCAmelCase_							:      Any=0.02		,       UpperCAmelCase_							:      Tuple=1.0		,       UpperCAmelCase_							:      Optional[int]=False		,       UpperCAmelCase_							:      Optional[Any]="sine"		,       UpperCAmelCase_							:      Any="resnet50"		,       UpperCAmelCase_							:      Optional[int]=True		,       UpperCAmelCase_							:      Union[str, Any]=False		,       UpperCAmelCase_							:      Any=2		,       UpperCAmelCase_							:      Optional[Any]=5		,       UpperCAmelCase_							:      Union[str, Any]=2		,       UpperCAmelCase_							:      Union[str, Any]=1		,       UpperCAmelCase_							:      Optional[int]=1		,       UpperCAmelCase_							:      Optional[int]=2		,       UpperCAmelCase_							:      Union[str, Any]=5		,       UpperCAmelCase_							:      List[str]=2		,       UpperCAmelCase_							:      List[str]=0.25		,       **UpperCAmelCase_							:      int		,       )					->Dict:



														"""simple docstring"""



														if backbone_config is not None and use_timm_backbone:
																					raise ValueError("""You can\'t specify both `backbone_config` and `use_timm_backbone`."""       )

														if not use_timm_backbone:
																					if backbone_config is None:
																												logger.info("""`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."""       )
																												snake_case_           =		CONFIG_MAPPING['resnet'](out_features=["""stage4"""]       )
																					elif isinstance(UpperCAmelCase_		,       UpperCAmelCase_       ):
																												snake_case_           =		backbone_config.get("""model_type"""       )
																												snake_case_           =		CONFIG_MAPPING[backbone_model_type]
																												snake_case_           =		config_class.from_dict(UpperCAmelCase_       )

														snake_case_           =		use_timm_backbone
														snake_case_           =		backbone_config
														snake_case_           =		num_channels
														snake_case_           =		num_queries
														snake_case_           =		d_model
														snake_case_           =		encoder_ffn_dim
														snake_case_           =		encoder_layers
														snake_case_           =		encoder_attention_heads
														snake_case_           =		decoder_ffn_dim
														snake_case_           =		decoder_layers
														snake_case_           =		decoder_attention_heads
														snake_case_           =		dropout
														snake_case_           =		attention_dropout
														snake_case_           =		activation_dropout
														snake_case_           =		activation_function
														snake_case_           =		init_std
														snake_case_           =		init_xavier_std
														snake_case_           =		encoder_layerdrop
														snake_case_           =		decoder_layerdrop
														snake_case_           =		encoder_layers
														snake_case_           =		auxiliary_loss
														snake_case_           =		position_embedding_type
														snake_case_           =		backbone
														snake_case_           =		use_pretrained_backbone
														snake_case_           =		dilation
														# Hungarian matcher
														snake_case_           =		class_cost
														snake_case_           =		bbox_cost
														snake_case_           =		giou_cost
														# Loss coefficients
														snake_case_           =		mask_loss_coefficient
														snake_case_           =		dice_loss_coefficient
														snake_case_           =		cls_loss_coefficient
														snake_case_           =		bbox_loss_coefficient
														snake_case_           =		giou_loss_coefficient
														snake_case_           =		focal_alpha
														super().__init__(is_encoder_decoder=UpperCAmelCase_		,       **UpperCAmelCase_       )



							@property
							def 		lowerCAmelCase       (				self							:      Union[str, Any]       )					->int:



														"""simple docstring"""



														return self.encoder_attention_heads



							@property
							def 		lowerCAmelCase       (				self							:      str       )					->int:



														"""simple docstring"""



														return self.d_model



							def 		lowerCAmelCase       (				self							:      Tuple       )					->int:



														"""simple docstring"""



														snake_case_           =		copy.deepcopy(self.__dict__       )
														if self.backbone_config is not None:
																					snake_case_           =		self.backbone_config.to_dict()
														snake_case_           =		self.__class__.model_type
														return output



class      __A     (__A):





							'''simple docstring'''

							__lowercase:		Optional[int]							      =    version.parse("""1.11""")



							@property
							def 		lowerCAmelCase       (				self							:      Optional[int]       )					->Any:



														"""simple docstring"""



														return OrderedDict(
														    [
														        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
														        ("""pixel_mask""", {0: """batch"""}),
														    ]       )



							@property
							def 		lowerCAmelCase       (				self							:      int       )					->Optional[Any]:



														"""simple docstring"""



														return 1E-5



							@property
							def 		lowerCAmelCase       (				self							:      Dict       )					->Union[str, Any]:



														"""simple docstring"""



														return 12







"""simple docstring"""
from math import factorial







def 						_a				(      _SCREAMING_SNAKE_CASE = 100				)    ->				int:
							return sum(int(_SCREAMING_SNAKE_CASE				) for x in str(factorial(_SCREAMING_SNAKE_CASE				)				)				)


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



