





from typing import Tuple, Union

from ...modeling_outputs import BackboneOutput
from ...modeling_utils import PreTrainedModel
from ...utils import is_timm_available, is_torch_available, requires_backends
from ...utils.backbone_utils import BackboneMixin
from .configuration_timm_backbone import TimmBackboneConfig


if is_timm_available():
     import timm


if is_torch_available():
     from torch import Tensor



class 							_UpperCAmelCase       (       _UpperCamelCase						,       _UpperCamelCase       ):

  """simple docstring"""


  a_              =					"""pixel_values"""
  a_              =					False
  a_              =					TimmBackboneConfig






  def __init__(							self					:						Tuple   ,    lowerCAmelCase_					:						Any   ,    **lowerCAmelCase_					:						Optional[int]	)				->		Optional[Any]:
     requires_backends(self   ,    'timm'	)
     super().__init__(lowerCAmelCase_	)
     __lowerCAmelCase				      =      config

     if config.backbone is None:
        raise ValueError('backbone is not set in the config. Please set it to a timm model name.'	)

     if config.backbone not in timm.list_models():
        raise ValueError(f"""backbone {config.backbone} is not supported by timm."""	)

     if hasattr(lowerCAmelCase_   ,    'out_features'	) and config.out_features is not None:
        raise ValueError('out_features is not supported by TimmBackbone. Please use out_indices instead.'	)

     __lowerCAmelCase				      =      getattr(lowerCAmelCase_   ,    'use_pretrained_backbone'   ,    lowerCAmelCase_	)
     if pretrained is None:
        raise ValueError('use_pretrained_backbone is not set in the config. Please set it to True or False.'	)

     # We just take the final layer by default. This matches the default for the transformers models.
     __lowerCAmelCase				      =      config.out_indices if getattr(lowerCAmelCase_   ,    'out_indices'   ,    lowerCAmelCase_	) is not None else (-1,)

     __lowerCAmelCase				      =      timm.create_model(
         config.backbone   ,    pretrained=lowerCAmelCase_   ,    features_only=config.features_only   ,    in_chans=config.num_channels   ,    out_indices=lowerCAmelCase_   ,    **lowerCAmelCase_   ,    )
     # These are used to control the output of the model when called. If output_hidden_states is True, then
     # return_layers is modified to include all layers.
     __lowerCAmelCase				      =      self._backbone.return_layers
     __lowerCAmelCase				      =      {layer['module']: str(lowerCAmelCase_	) for i, layer in enumerate(self._backbone.feature_info.info	)}
     super()._init_backbone(lowerCAmelCase_	)






  @classmethod
  def 							lowercase						(							cls					:						int   ,    lowerCAmelCase_					:						Dict   ,    *lowerCAmelCase_					:						Dict   ,    **lowerCAmelCase_					:						Union[str, Any]	)				->		Optional[int]:
     requires_backends(cls   ,    ['vision', 'timm']	)
     from ...models.timm_backbone import TimmBackboneConfig

     __lowerCAmelCase				      =      kwargs.pop('config'   ,    TimmBackboneConfig()	)

     __lowerCAmelCase				      =      kwargs.pop('use_timm_backbone'   ,    lowerCAmelCase_	)
     if not use_timm:
        raise ValueError('use_timm_backbone must be True for timm backbones'	)

     __lowerCAmelCase				      =      kwargs.pop('num_channels'   ,    config.num_channels	)
     __lowerCAmelCase				      =      kwargs.pop('features_only'   ,    config.features_only	)
     __lowerCAmelCase				      =      kwargs.pop('use_pretrained_backbone'   ,    config.use_pretrained_backbone	)
     __lowerCAmelCase				      =      kwargs.pop('out_indices'   ,    config.out_indices	)
     __lowerCAmelCase				      =      TimmBackboneConfig(
         backbone=lowerCAmelCase_   ,    num_channels=lowerCAmelCase_   ,    features_only=lowerCAmelCase_   ,    use_pretrained_backbone=lowerCAmelCase_   ,    out_indices=lowerCAmelCase_   ,    )
     return super()._from_config(lowerCAmelCase_   ,    **lowerCAmelCase_	)






  def 							lowercase						(							self					:						Tuple   ,    lowerCAmelCase_					:						int	)				->		Dict:
     pass






  def 							lowercase						(							self					:						Optional[int]   ,    lowerCAmelCase_					:						Union[str, Any]   ,    lowerCAmelCase_					:						List[Any]=None   ,    lowerCAmelCase_					:						List[str]=None   ,    lowerCAmelCase_					:						Any=None   ,    **lowerCAmelCase_					:						Dict	)				->		Union[BackboneOutput, Tuple[Tensor, ...]]:
     __lowerCAmelCase				      =      return_dict if return_dict is not None else self.config.use_return_dict
     __lowerCAmelCase				      =      (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     __lowerCAmelCase				      =      output_attentions if output_attentions is not None else self.config.output_attentions

     if output_attentions:
        raise ValueError('Cannot output attentions for timm backbones at the moment'	)

     if output_hidden_states:
        # We modify the return layers to include all the stages of the backbone
        __lowerCAmelCase				      =      self._all_layers
        __lowerCAmelCase				      =      self._backbone(lowerCAmelCase_   ,    **lowerCAmelCase_	)
        __lowerCAmelCase				      =      self._return_layers
        __lowerCAmelCase				      =      tuple(hidden_states[i] for i in self.out_indices	)
     else:
        __lowerCAmelCase				      =      self._backbone(lowerCAmelCase_   ,    **lowerCAmelCase_	)
        __lowerCAmelCase				      =      None

     __lowerCAmelCase				      =      tuple(lowerCAmelCase_	)
     __lowerCAmelCase				      =      tuple(lowerCAmelCase_	) if hidden_states is not None else None

     if not return_dict:
        __lowerCAmelCase				      =      (feature_maps,)
        if output_hidden_states:
           __lowerCAmelCase				      =      output + (hidden_states,)
        return output

     return BackboneOutput(feature_maps=lowerCAmelCase_   ,    hidden_states=lowerCAmelCase_   ,    attentions=lowerCAmelCase_	)








from math import sqrt

def   __snake_case    (       _lowerCAmelCase			:			int						)			->    bool:

   if 1 < number < 4:
      # 2 and 3 are primes
      return True
   elif number < 2 or number % 2 == 0 or number % 3 == 0:
      # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
      return False

   # All primes number are in format of 6k +/- 1
   for i in range(5					,					int(sqrt(_lowerCAmelCase						) + 1						)					,					6						):
      if number % i == 0 or number % (i + 2) == 0:
         return False
   return True

def   __snake_case    (       _lowerCAmelCase			:			int = 10001						)			->    int:
   A_       :					Any        =      0
   A_       :					Tuple        =      1
   while count != nth and number < 3:
      number += 1
      if is_prime(_lowerCAmelCase						):
         count += 1
   while count != nth:
      number += 2
      if is_prime(_lowerCAmelCase						):
         count += 1
   return number


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