



"""simple docstring"""

import copy

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


lowercase__    :  Tuple							    =	logging.get_logger(__name__)

lowercase__    :  Union[str, 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        _UpperCAmelCase       (			lowerCAmelCase__):
 _lowerCAmelCase   :			Dict							=		"""deformable_detr"""
 _lowerCAmelCase   :			Any							=		{
     """hidden_size""": """d_model""",
     """num_attention_heads""": """encoder_attention_heads""",
 }

 def __init__(     self		:       List[str]  ,     lowercase_		:       Dict=True  ,     lowercase_		:       Any=None  ,     lowercase_		:       str=3  ,     lowercase_		:       Union[str, Any]=300  ,     lowercase_		:       int=1024  ,     lowercase_		:       Union[str, Any]=6  ,     lowercase_		:       Optional[int]=1024  ,     lowercase_		:       List[Any]=8  ,     lowercase_		:       Any=6  ,     lowercase_		:       Dict=1024  ,     lowercase_		:       Dict=8  ,     lowercase_		:       List[Any]=0.0  ,     lowercase_		:       Dict=True  ,     lowercase_		:       int="relu"  ,     lowercase_		:       Optional[Any]=256  ,     lowercase_		:       Optional[Any]=0.1  ,     lowercase_		:       Union[str, Any]=0.0  ,     lowercase_		:       Tuple=0.0  ,     lowercase_		:       Dict=0.02  ,     lowercase_		:       Optional[Any]=1.0  ,     lowercase_		:       List[Any]=True  ,     lowercase_		:       Optional[int]=False  ,     lowercase_		:       List[str]="sine"  ,     lowercase_		:       Optional[Any]="resnet50"  ,     lowercase_		:       List[Any]=True  ,     lowercase_		:       Union[str, Any]=False  ,     lowercase_		:       Union[str, Any]=4  ,     lowercase_		:       Optional[Any]=4  ,     lowercase_		:       int=4  ,     lowercase_		:       int=False  ,     lowercase_		:       Tuple=300  ,     lowercase_		:       List[Any]=False  ,     lowercase_		:       int=1  ,     lowercase_		:       Optional[int]=5  ,     lowercase_		:       Optional[Any]=2  ,     lowercase_		:       int=1  ,     lowercase_		:       Tuple=1  ,     lowercase_		:       str=5  ,     lowercase_		:       List[str]=2  ,     lowercase_		:       int=0.1  ,     lowercase_		:       Optional[Any]=0.25  ,     lowercase_		:       List[str]=False  ,     **lowercase_		:       List[Any]  ,     ):
     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_ :     int				=	CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']				)
         elif isinstance(lowercase_  ,     lowercase_				):
             snake_case_ :     Optional[int]				=	backbone_config.get('''model_type'''				)
             snake_case_ :     int				=	CONFIG_MAPPING[backbone_model_type]
             snake_case_ :     Optional[int]				=	config_class.from_dict(lowercase_				)
     snake_case_ :     Union[str, Any]				=	use_timm_backbone
     snake_case_ :     List[Any]				=	backbone_config
     snake_case_ :     List[Any]				=	num_channels
     snake_case_ :     List[Any]				=	num_queries
     snake_case_ :     List[Any]				=	max_position_embeddings
     snake_case_ :     Optional[Any]				=	d_model
     snake_case_ :     int				=	encoder_ffn_dim
     snake_case_ :     Any				=	encoder_layers
     snake_case_ :     Any				=	encoder_attention_heads
     snake_case_ :     int				=	decoder_ffn_dim
     snake_case_ :     Any				=	decoder_layers
     snake_case_ :     List[Any]				=	decoder_attention_heads
     snake_case_ :     Tuple				=	dropout
     snake_case_ :     Optional[Any]				=	attention_dropout
     snake_case_ :     List[str]				=	activation_dropout
     snake_case_ :     List[str]				=	activation_function
     snake_case_ :     str				=	init_std
     snake_case_ :     str				=	init_xavier_std
     snake_case_ :     str				=	encoder_layerdrop
     snake_case_ :     str				=	auxiliary_loss
     snake_case_ :     str				=	position_embedding_type
     snake_case_ :     str				=	backbone
     snake_case_ :     List[str]				=	use_pretrained_backbone
     snake_case_ :     Union[str, Any]				=	dilation
     # deformable attributes
     snake_case_ :     List[Any]				=	num_feature_levels
     snake_case_ :     List[Any]				=	encoder_n_points
     snake_case_ :     Tuple				=	decoder_n_points
     snake_case_ :     Union[str, Any]				=	two_stage
     snake_case_ :     Optional[int]				=	two_stage_num_proposals
     snake_case_ :     List[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
     snake_case_ :     Optional[Any]				=	class_cost
     snake_case_ :     Union[str, Any]				=	bbox_cost
     snake_case_ :     List[str]				=	giou_cost
     # Loss coefficients
     snake_case_ :     Any				=	mask_loss_coefficient
     snake_case_ :     Tuple				=	dice_loss_coefficient
     snake_case_ :     str				=	bbox_loss_coefficient
     snake_case_ :     Tuple				=	giou_loss_coefficient
     snake_case_ :     List[Any]				=	eos_coefficient
     snake_case_ :     Optional[int]				=	focal_alpha
     snake_case_ :     Tuple				=	disable_custom_kernels
     super().__init__(is_encoder_decoder=lowercase_  ,     **lowercase_				)

 @property
 def 						_snake_case					(     self		:       Tuple				):
     return self.encoder_attention_heads

 @property
 def 						_snake_case					(     self		:       Tuple				):
     return self.d_model






 def 						_snake_case					(     self		:       Optional[Any]				):
     snake_case_ :     Optional[Any]				=	copy.deepcopy(self.__dict__				)
     if self.backbone_config is not None:
         snake_case_ :     Union[str, Any]				=	self.backbone_config.to_dict()
     snake_case_ :     Optional[int]				=	self.__class__.model_type
     return output










"""simple docstring"""

import sys

lowercase__    :  Dict							    =	(
    '''73167176531330624919225119674426574742355349194934'''
    '''96983520312774506326239578318016984801869478851843'''
    '''85861560789112949495459501737958331952853208805511'''
    '''12540698747158523863050715693290963295227443043557'''
    '''66896648950445244523161731856403098711121722383113'''
    '''62229893423380308135336276614282806444486645238749'''
    '''30358907296290491560440772390713810515859307960866'''
    '''70172427121883998797908792274921901699720888093776'''
    '''65727333001053367881220235421809751254540594752243'''
    '''52584907711670556013604839586446706324415722155397'''
    '''53697817977846174064955149290862569321978468622482'''
    '''83972241375657056057490261407972968652414535100474'''
    '''82166370484403199890008895243450658541227588666881'''
    '''16427171479924442928230863465674813919123162824586'''
    '''17866458359124566529476545682848912883142607690042'''
    '''24219022671055626321111109370544217506941658960408'''
    '''07198403850962455444362981230987879927244284909188'''
    '''84580156166097919133875499200524063689912560717606'''
    '''05886116467109405077541002256983155200055935729725'''
    '''71636269561882670428252483600823257530420752963450'''
)




def __lowercase			(							_a    ):
    snake_case_ :     List[Any]				=	1
    for digit in s:
        product *= int(_a    )
    return product




def __lowercase			(							_a = N    ):
    snake_case_ :     Optional[int]				=	-sys.maxsize - 1
    snake_case_ :     str				=	n[:13]
    snake_case_ :     List[Any]				=	13
    while cur_index < len(_a    ) - 13:
        if int(n[cur_index]    ) >= int(substr[0]    ):
            snake_case_ :     int				=	substr[1:] + n[cur_index]
            cur_index += 1
        else:
            snake_case_ :     Optional[Any]				=	max(_a		,			str_eval(_a    )    )
            snake_case_ :     Any				=	n[cur_index : cur_index + 13]
            cur_index += 13
    return largest_product


if __name__ == "__main__":
     print(f'{solution() = }')





