

'''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


lowerCAmelCase__						:       str										=						logging.get_logger(__name__)

lowerCAmelCase__						:       Optional[int]										=						{
    """microsoft/conditional-detr-resnet-50""": (
        """https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json"""
    ),
}




class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    """conditional_detr"""
						__UpperCAmelCase			     =    ["""past_key_values"""]
						__UpperCAmelCase			     =    {
						    """hidden_size""": """d_model""",
						    """num_attention_heads""": """encoder_attention_heads""",
						}







						def __init__(							self					:      Union[str, Any]			,			snake_case_					:      str=True			,			snake_case_					:      Optional[Any]=None			,			snake_case_					:      Optional[int]=3			,			snake_case_					:      str=3_0_0			,			snake_case_					:      int=6			,			snake_case_					:      List[str]=2_0_4_8			,			snake_case_					:      Optional[Any]=8			,			snake_case_					:      Optional[Any]=6			,			snake_case_					:      Dict=2_0_4_8			,			snake_case_					:      List[str]=8			,			snake_case_					:      Dict=0.0			,			snake_case_					:      Any=0.0			,			snake_case_					:      int=True			,			snake_case_					:      Any="relu"			,			snake_case_					:      Union[str, Any]=2_5_6			,			snake_case_					:      List[str]=0.1			,			snake_case_					:      str=0.0			,			snake_case_					:      List[Any]=0.0			,			snake_case_					:      Union[str, Any]=0.0_2			,			snake_case_					:      int=1.0			,			snake_case_					:      Optional[int]=False			,			snake_case_					:      Optional[Any]="sine"			,			snake_case_					:      Tuple="resnet50"			,			snake_case_					:      int=True			,			snake_case_					:      Optional[Any]=False			,			snake_case_					:      int=2			,			snake_case_					:      List[Any]=5			,			snake_case_					:      Dict=2			,			snake_case_					:      str=1			,			snake_case_					:      Optional[Any]=1			,			snake_case_					:      Optional[Any]=2			,			snake_case_					:      Tuple=5			,			snake_case_					:      Tuple=2			,			snake_case_					:      int=0.2_5			,			**snake_case_					:      Optional[Any]			,			):



								'''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__						:       Any       						=  CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']  )
										elif isinstance(snake_case_			,			snake_case_  ):
												snake_case__						:       Union[str, Any]       						=  backbone_config.get('''model_type'''  )
												snake_case__						:       Optional[int]       						=  CONFIG_MAPPING[backbone_model_type]
												snake_case__						:       List[Any]       						=  config_class.from_dict(snake_case_  )

								snake_case__						:       Union[str, Any]       						=  use_timm_backbone
								snake_case__						:       Union[str, Any]       						=  backbone_config
								snake_case__						:       Dict       						=  num_channels
								snake_case__						:       Union[str, Any]       						=  num_queries
								snake_case__						:       Optional[Any]       						=  d_model
								snake_case__						:       Any       						=  encoder_ffn_dim
								snake_case__						:       Optional[Any]       						=  encoder_layers
								snake_case__						:       Optional[Any]       						=  encoder_attention_heads
								snake_case__						:       Optional[int]       						=  decoder_ffn_dim
								snake_case__						:       Dict       						=  decoder_layers
								snake_case__						:       str       						=  decoder_attention_heads
								snake_case__						:       str       						=  dropout
								snake_case__						:       Optional[int]       						=  attention_dropout
								snake_case__						:       str       						=  activation_dropout
								snake_case__						:       Tuple       						=  activation_function
								snake_case__						:       Union[str, Any]       						=  init_std
								snake_case__						:       Union[str, Any]       						=  init_xavier_std
								snake_case__						:       str       						=  encoder_layerdrop
								snake_case__						:       Union[str, Any]       						=  decoder_layerdrop
								snake_case__						:       Tuple       						=  encoder_layers
								snake_case__						:       Any       						=  auxiliary_loss
								snake_case__						:       List[str]       						=  position_embedding_type
								snake_case__						:       Dict       						=  backbone
								snake_case__						:       Optional[int]       						=  use_pretrained_backbone
								snake_case__						:       Optional[int]       						=  dilation
								# Hungarian matcher
								snake_case__						:       List[Any]       						=  class_cost
								snake_case__						:       List[Any]       						=  bbox_cost
								snake_case__						:       Optional[Any]       						=  giou_cost
								# Loss coefficients
								snake_case__						:       str       						=  mask_loss_coefficient
								snake_case__						:       int       						=  dice_loss_coefficient
								snake_case__						:       Any       						=  cls_loss_coefficient
								snake_case__						:       List[str]       						=  bbox_loss_coefficient
								snake_case__						:       str       						=  giou_loss_coefficient
								snake_case__						:       Dict       						=  focal_alpha
								super().__init__(is_encoder_decoder=snake_case_			,			**snake_case_  )







						@property
						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								return self.encoder_attention_heads







						@property
						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								return self.d_model







						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  copy.deepcopy(self.__dict__  )
								if self.backbone_config is not None:
										snake_case__						:       int       						=  self.backbone_config.to_dict()
								snake_case__						:       str       						=  self.__class__.model_type
								return output





class     a			(				SCREAMING_SNAKE_CASE       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    version.parse("""1.11"""       )







						@property
						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



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







						@property
						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								return 1e-5







						@property
						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								return 1_2






'''simple docstring'''


from collections.abc import Generator




def 	_a       (				):

		"""simple docstring"""

		snake_case__						,       snake_case__						:       List[Any]       						=  0, 1
		while True:
				snake_case__						,       snake_case__						:       str       						=  b, a + b
				yield b




def 	_a       (				__lowerCAmelCase		:      int = 10_00     ):

		"""simple docstring"""

		snake_case__						:       Optional[int]       						=  1
		snake_case__						:       Tuple       						=  fibonacci_generator()
		while len(str(next(__lowerCAmelCase     )     )     ) < n:
				answer += 1
		return answer + 1


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



