



"""simple docstring"""






import copy

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


__snake_case							:   Any      =    logging.get_logger(__name__)

__snake_case							:   Optional[Any]      =    {
    'SenseTime/deformable-detr': 'https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json',
    # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr
}



class 			A__   (  __SCREAMING_SNAKE_CASE							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE          =	'deformable_detr'
	SCREAMING_SNAKE_CASE          =	{
	    'hidden_size': 'd_model',
	    'num_attention_heads': 'encoder_attention_heads',
	}

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

				"""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.")
										__lowerCAmelCase      :  str												=       CONFIG_MAPPING["resnet"](out_features=["stage4"])
							elif isinstance(_SCREAMING_SNAKE_CASE       ,			_SCREAMING_SNAKE_CASE):
										__lowerCAmelCase      :  Dict												=       backbone_config.get("model_type")
										__lowerCAmelCase      :  int												=       CONFIG_MAPPING[backbone_model_type]
										__lowerCAmelCase      :  Dict												=       config_class.from_dict(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase      :  Optional[int]												=       use_timm_backbone
				__lowerCAmelCase      :  List[str]												=       backbone_config
				__lowerCAmelCase      :  Union[str, Any]												=       num_channels
				__lowerCAmelCase      :  Optional[Any]												=       num_queries
				__lowerCAmelCase      :  int												=       max_position_embeddings
				__lowerCAmelCase      :  str												=       d_model
				__lowerCAmelCase      :  Optional[int]												=       encoder_ffn_dim
				__lowerCAmelCase      :  str												=       encoder_layers
				__lowerCAmelCase      :  str												=       encoder_attention_heads
				__lowerCAmelCase      :  int												=       decoder_ffn_dim
				__lowerCAmelCase      :  List[Any]												=       decoder_layers
				__lowerCAmelCase      :  Dict												=       decoder_attention_heads
				__lowerCAmelCase      :  List[Any]												=       dropout
				__lowerCAmelCase      :  List[str]												=       attention_dropout
				__lowerCAmelCase      :  Any												=       activation_dropout
				__lowerCAmelCase      :  List[str]												=       activation_function
				__lowerCAmelCase      :  str												=       init_std
				__lowerCAmelCase      :  List[str]												=       init_xavier_std
				__lowerCAmelCase      :  Tuple												=       encoder_layerdrop
				__lowerCAmelCase      :  List[Any]												=       auxiliary_loss
				__lowerCAmelCase      :  Optional[int]												=       position_embedding_type
				__lowerCAmelCase      :  Union[str, Any]												=       backbone
				__lowerCAmelCase      :  Dict												=       use_pretrained_backbone
				__lowerCAmelCase      :  Tuple												=       dilation
				# deformable attributes
				__lowerCAmelCase      :  Optional[Any]												=       num_feature_levels
				__lowerCAmelCase      :  Optional[Any]												=       encoder_n_points
				__lowerCAmelCase      :  Optional[Any]												=       decoder_n_points
				__lowerCAmelCase      :  List[Any]												=       two_stage
				__lowerCAmelCase      :  Union[str, Any]												=       two_stage_num_proposals
				__lowerCAmelCase      :  Any												=       with_box_refine
				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
				__lowerCAmelCase      :  List[Any]												=       class_cost
				__lowerCAmelCase      :  str												=       bbox_cost
				__lowerCAmelCase      :  int												=       giou_cost
				# Loss coefficients
				__lowerCAmelCase      :  int												=       mask_loss_coefficient
				__lowerCAmelCase      :  str												=       dice_loss_coefficient
				__lowerCAmelCase      :  int												=       bbox_loss_coefficient
				__lowerCAmelCase      :  Any												=       giou_loss_coefficient
				__lowerCAmelCase      :  int												=       eos_coefficient
				__lowerCAmelCase      :  Tuple												=       focal_alpha
				__lowerCAmelCase      :  Dict												=       disable_custom_kernels
				super().__init__(is_encoder_decoder=_SCREAMING_SNAKE_CASE       ,			**_SCREAMING_SNAKE_CASE)

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

				"""simple docstring"""

				return self.encoder_attention_heads

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

				"""simple docstring"""

				return self.d_model







	def 							_SCREAMING_SNAKE_CASE   (     self:		List[Any])				->       List[str]:

				"""simple docstring"""

				__lowerCAmelCase      :  Optional[Any]												=       copy.deepcopy(self.__dict__)
				if self.backbone_config is not None:
							__lowerCAmelCase      :  int												=       self.backbone_config.to_dict()
				__lowerCAmelCase      :  Any												=       self.__class__.model_type
				return output




"""simple docstring"""






def 			_lowercase				(  )						->   int:
			return 1


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else two_pence(x - 2	) + one_pence()


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else five_pence(x - 5	) + two_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else ten_pence(x - 10	) + five_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else twenty_pence(x - 20	) + ten_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else fifty_pence(x - 50	) + twenty_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else one_pound(x - 100	) + fifty_pence(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   int:
			return 0 if x < 0 else two_pound(x - 200	) + one_pound(__snake_case	)


def 			_lowercase				(  __snake_case = 200	)						->   int:
			return two_pound(__snake_case	)


if __name__ == "__main__":
	print(solution(int(input().strip())))