code: 
  
  import enum
  import inspect
  from typing import Iterable, List, Optional, Tuple, Union
  
  
  
  
  
  
  
  class 		__magic_name__    (							enum.Enum							):
     lowerCamelCase__				:			List[Any]												=     '''timm'''
     lowerCamelCase__				:			Any												=     '''transformers'''
  
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Any			,   _A   :				str			,   _A   :				Optional[int]							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    if stage_names is None:
      raise ValueError('''Stage_names must be set for transformers backbones'''							)
  
    if out_features is not None:
      if not isinstance(__lowerCAmelCase			,   (list,)							):
        raise ValueError(F"""out_features must be a list {type(__lowerCAmelCase							)}"""							)
      if any(feat not in stage_names for feat in out_features							):
        raise ValueError(F"""out_features must be a subset of stage_names: {stage_names} got {out_features}"""							)
  
    if out_indices is not None:
      if not isinstance(__lowerCAmelCase			,   (list, tuple)							):
        raise ValueError(F"""out_indices must be a list or tuple, got {type(__lowerCAmelCase							)}"""							)
      if any(idx >= len(__lowerCAmelCase							) for idx in out_indices							):
        raise ValueError('''out_indices must be valid indices for stage_names {stage_names}, got {out_indices}'''							)
  
    if out_features is not None and out_indices is not None:
      if len(__lowerCAmelCase							) != len(__lowerCAmelCase							):
        raise ValueError('''out_features and out_indices should have the same length if both are set'''							)
      if out_features != [stage_names[idx] for idx in out_indices]:
        raise ValueError('''out_features and out_indices should correspond to the same stages if both are set'''							)
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				Optional[Any]			,   _A   :				str			,   _A   :				List[Any]			,   ):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    if out_indices is None and out_features is None:
      a__						=[len(__lowerCAmelCase							) - 1]
      a__						=[stage_names[-1]]
    elif out_indices is None and out_features is not None:
      a__						=[stage_names.index(__lowerCAmelCase							) for layer in out_features]
    elif out_features is None and out_indices is not None:
      a__						=[stage_names[idx] for idx in out_indices]
    return out_features, out_indices
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				List[str]			,   _A   :				int			,   _A   :				Tuple			,   ):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    verify_out_features_out_indices(out_features=__lowerCAmelCase			,   out_indices=__lowerCAmelCase			,   stage_names=__lowerCAmelCase							)
    a__						=_align_output_features_output_indices(
        out_features=__lowerCAmelCase			,   out_indices=__lowerCAmelCase			,   stage_names=__lowerCAmelCase							)
    # Verify that the aligned out_features and out_indices are valid
    verify_out_features_out_indices(out_features=__lowerCAmelCase			,   out_indices=__lowerCAmelCase			,   stage_names=__lowerCAmelCase							)
    return output_features, output_indices
  
  
  
  
  
  
  
  class 		__magic_name__    :
     lowerCamelCase__				:			Optional[BackboneType]												=     None
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       if getattr(self,					'''_backbone''',					lowercase_ ) is None:
         raise ValueError('''self._backbone must be set before calling _init_timm_backbone''' )
  
       # These will diagree with the defaults for the transformers models e.g. for resnet50
       # the transformer model has out_features = ['stem', 'stage1', 'stage2', 'stage3', 'stage4']
       # the timm model has out_features = ['act', 'layer1', 'layer2', 'layer3', 'layer4']
       a__						=[stage["module"] for stage in self._backbone.feature_info.info]
       a__						=[stage["num_chs"] for stage in self._backbone.feature_info.info]
       a__						=self._backbone.feature_info.out_indices
       a__						=self._backbone.feature_info.module_name()
  
       # We verify the out indices and out features are valid
       verify_out_features_out_indices(
           out_features=lowercase_,					out_indices=lowercase_,					stage_names=self.stage_names )
       a__						=out_features, out_indices
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=getattr(lowercase_,					'''stage_names''' )
       a__						=getattr(lowercase_,					'''out_features''',					lowercase_ )
       a__						=getattr(lowercase_,					'''out_indices''',					lowercase_ )
  
       a__						=stage_names
       a__						=get_aligned_output_features_output_indices(
           out_features=lowercase_,					out_indices=lowercase_,					stage_names=lowercase_ )
       # Number of channels for each stage. This is set in the transformer backbone model init
       a__						=None
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=config
  
       a__						=getattr(lowercase_,					'''use_timm_backbone''',					lowercase_ )
       a__						=BackboneType.TIMM if self.use_timm_backbone else BackboneType.TRANSFORMERS
  
       if self.backbone_type == BackboneType.TIMM:
         self._init_timm_backbone(lowercase_ )
       elif self.backbone_type == BackboneType.TRANSFORMERS:
         self._init_transformers_backbone(lowercase_ )
       else:
         raise ValueError(F"""backbone_type {self.backbone_type} not supported.""" )
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					int:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return self._out_features
  
  
  
     @out_features.setter
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=get_aligned_output_features_output_indices(
           out_features=lowercase_,					out_indices=lowercase_,					stage_names=self.stage_names )
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return self._out_indices
  
  
  
     @out_indices.setter
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Tuple:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=get_aligned_output_features_output_indices(
           out_features=lowercase_,					out_indices=lowercase_,					stage_names=self.stage_names )
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Union[str, Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return {stage: self.num_features[i] for i, stage in enumerate(self.stage_names )}
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return [self.out_feature_channels[name] for name in self.out_features]
  
  
  
     def 				_UpperCAmelCase				(       self,					*lowercase_,					**lowercase_ )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=dict(inspect.signature(self.forward ).parameters )
       a__						={k: v for k, v in kwargs.items() if k in signature}
       return self(*lowercase_,					**lowercase_ )
  
  
  
     def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					)							->					List[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       raise NotImplementedError('''This method should be implemented by the derived class.''' )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=super().to_dict()
       a__						=output.pop('''_out_features''' )
       a__						=output.pop('''_out_indices''' )
       return output
  
  
  
  
  
  
  
  class 		__magic_name__    :
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					List[str]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return self._out_features
  
  
  
     @out_features.setter
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Optional[Any]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=get_aligned_output_features_output_indices(
           out_features=lowercase_,					out_indices=lowercase_,					stage_names=self.stage_names )
  
  
  
     @property
     def 				_UpperCAmelCase				(       self )							->					Optional[int]:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       return self._out_indices
  
  
  
     @out_indices.setter
     def 				_UpperCAmelCase				(       self,					lowercase_ )							->					Dict:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=get_aligned_output_features_output_indices(
           out_features=lowercase_,					out_indices=lowercase_,					stage_names=self.stage_names )
  
  
  
     def 				_UpperCAmelCase				(       self )							->					Any:
  
  
  
  
  
  
       """simple docstring"""
  
  
  
  
  
  
       a__						=super().to_dict()
       a__						=output.pop('''_out_features''' )
       a__						=output.pop('''_out_indices''' )
       return output
  
style_context: 
  
  import math
  from decimal import Decimal, getcontext
  
  
  
  
  def     UpperCAmelCase__       (    _A   :				int = 4_00_00_00							):
  
  
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
  
    try:
      a__						=int(_A							)
    except (TypeError, ValueError):
      raise TypeError('''Parameter n must be int or castable to int.'''							)
    if n <= 0:
      raise ValueError('''Parameter n must be greater than or equal to one.'''							)
    a__						=1_00
    a__						=(Decimal(5							) ** Decimal(0.5							) + 1) / Decimal(2							)
  
    a__						=(math.floor(math.log(n * (phi + 2)			,   _A							) - 1							) // 3) * 3 + 2
    a__						=Decimal(round(phi ** Decimal(index + 1							)							)							) / (phi + 2)
    a__						=num // 2
    return int(_A							)
  
  
  if __name__ == "__main__":
         print(f"""{solution() = }""")
  