
import copy

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


lowercase    :   Union[str, Any]						=			logging.get_logger(__name__)

lowercase    :   Any						=			{
    'ut/deta': 'https://huggingface.co/ut/deta/resolve/main/config.json',
}




class 					lowerCamelCase__				(							__lowercase):




	'''simple docstring'''




	_A								=	'deta'
	_A								=	{
	    'hidden_size': 'd_model',
	    'num_attention_heads': 'encoder_attention_heads',
	}







	def __init__(   self						:int	,  a						:Tuple=None	,  a						:Optional[int]=9_0_0	,  a						:List[str]=2_0_4_8	,  a						:Dict=6	,  a						:Optional[Any]=2_0_4_8	,  a						:List[Any]=8	,  a						:int=6	,  a						:List[Any]=1_0_2_4	,  a						:str=8	,  a						:str=0.0	,  a						:Optional[Any]=True	,  a						:int="relu"	,  a						:str=2_5_6	,  a						:Dict=0.1	,  a						:Optional[Any]=0.0	,  a						:List[Any]=0.0	,  a						:Any=0.02	,  a						:Optional[int]=1.0	,  a						:Dict=True	,  a						:Tuple=False	,  a						:Optional[int]="sine"	,  a						:Union[str, Any]=5	,  a						:int=4	,  a						:Optional[Any]=4	,  a						:Tuple=True	,  a						:Optional[int]=3_0_0	,  a						:Optional[int]=True	,  a						:Union[str, Any]=True	,  a						:List[str]=1	,  a						:Optional[int]=5	,  a						:Any=2	,  a						:int=1	,  a						:Dict=1	,  a						:int=5	,  a						:Optional[Any]=2	,  a						:Dict=0.1	,  a						:str=0.25	,  **a						:int	,  )						->					int:
								if backbone_config is None:
															logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."		)
															__UpperCamelCase      :  Tuple       =   CONFIG_MAPPING["resnet"](out_features=["stage2", "stage3", "stage4"]		)
								else:
															if isinstance(a	,  a		):
																						__UpperCamelCase      :  Optional[int]       =   backbone_config.pop("model_type"		)
																						__UpperCamelCase      :  List[str]       =   CONFIG_MAPPING[backbone_model_type]
																						__UpperCamelCase      :  List[str]       =   config_class.from_dict(a		)

								__UpperCamelCase      :  Union[str, Any]       =   backbone_config
								__UpperCamelCase      :  int       =   num_queries
								__UpperCamelCase      :  Dict       =   max_position_embeddings
								__UpperCamelCase      :  str       =   d_model
								__UpperCamelCase      :  List[str]       =   encoder_ffn_dim
								__UpperCamelCase      :  Union[str, Any]       =   encoder_layers
								__UpperCamelCase      :  Optional[Any]       =   encoder_attention_heads
								__UpperCamelCase      :  int       =   decoder_ffn_dim
								__UpperCamelCase      :  Dict       =   decoder_layers
								__UpperCamelCase      :  Any       =   decoder_attention_heads
								__UpperCamelCase      :  str       =   dropout
								__UpperCamelCase      :  Dict       =   attention_dropout
								__UpperCamelCase      :  Union[str, Any]       =   activation_dropout
								__UpperCamelCase      :  Dict       =   activation_function
								__UpperCamelCase      :  int       =   init_std
								__UpperCamelCase      :  str       =   init_xavier_std
								__UpperCamelCase      :  List[Any]       =   encoder_layerdrop
								__UpperCamelCase      :  str       =   auxiliary_loss
								__UpperCamelCase      :  Tuple       =   position_embedding_type
								# deformable attributes
								__UpperCamelCase      :  List[Any]       =   num_feature_levels
								__UpperCamelCase      :  Union[str, Any]       =   encoder_n_points
								__UpperCamelCase      :  Tuple       =   decoder_n_points
								__UpperCamelCase      :  Optional[int]       =   two_stage
								__UpperCamelCase      :  Dict       =   two_stage_num_proposals
								__UpperCamelCase      :  List[str]       =   with_box_refine
								__UpperCamelCase      :  str       =   assign_first_stage
								if two_stage is True and with_box_refine is False:
															raise ValueError("If two_stage is True, with_box_refine must be True."		)
								# Hungarian matcher
								__UpperCamelCase      :  str       =   class_cost
								__UpperCamelCase      :  Any       =   bbox_cost
								__UpperCamelCase      :  Optional[Any]       =   giou_cost
								# Loss coefficients
								__UpperCamelCase      :  int       =   mask_loss_coefficient
								__UpperCamelCase      :  List[str]       =   dice_loss_coefficient
								__UpperCamelCase      :  Optional[Any]       =   bbox_loss_coefficient
								__UpperCamelCase      :  List[Any]       =   giou_loss_coefficient
								__UpperCamelCase      :  Dict       =   eos_coefficient
								__UpperCamelCase      :  int       =   focal_alpha
								super().__init__(is_encoder_decoder=a	,  **a		)







	@property
	def   _lowerCamelCase							(   self						:Optional[Any]		)						->					int:
								return self.encoder_attention_heads







	@property
	def   _lowerCamelCase							(   self						:List[Any]		)						->					int:
								return self.d_model







	def   _lowerCamelCase							(   self						:List[str]		)						->					List[Any]:
								__UpperCamelCase      :  Any       =   copy.deepcopy(self.__dict__		)
								__UpperCamelCase      :  Dict       =   self.backbone_config.to_dict()
								__UpperCamelCase      :  Dict       =   self.__class__.model_type
								return output

def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  Tuple       =   1
							for i in range(1		,    num + 1):
														fact *= i
							return fact




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  Dict       =   0
							while number > 0:
														__UpperCamelCase      :  List[Any]       =   number % 10
														sum_of_digits += last_digit
														__UpperCamelCase      :  List[Any]       =   number // 10  # Removing the last_digit from the given number
							return sum_of_digits




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int = 100)   ->       int:






							'''simple docstring'''





							__UpperCamelCase      :  Optional[Any]       =   factorial(_lowerCamelCase)
							__UpperCamelCase      :  Tuple       =   split_and_add(_lowerCamelCase)
							return result


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