






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 ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


snake_case_           =      logging.get_logger(__name__)

snake_case_           =      {
    'microsoft/resnet-50': 'https://huggingface.co/microsoft/resnet-50/blob/main/config.json',
}

class 		SCREAMING_SNAKE_CASE__    (	_UpperCAmelCase						,				_UpperCAmelCase  ):
      A_						:    Tuple							=   'resnet'
      A_						:    List[Any]							=   ['basic', 'bottleneck']


      def __init__(self	:				Optional[Any]    ,      a__	:				Dict=3    ,      a__	:				str=64    ,      a__	:				Dict=[256, 512, 1024, 2048]    ,      a__	:				str=[3, 4, 6, 3]    ,      a__	:				Union[str, Any]="bottleneck"    ,      a__	:				int="relu"    ,      a__	:				List[Any]=False    ,      a__	:				Optional[Any]=None    ,      a__	:				Union[str, Any]=None    ,      **a__	:				int    ,      ):





         """simple docstring"""



         super().__init__(**a__				)
         if layer_type not in self.layer_types:
            raise ValueError(f"""layer_type={layer_type} is not one of {','.join(self.layer_types				)}"""				)
         __snake_case								=       num_channels
         __snake_case								=       embedding_size
         __snake_case								=       hidden_sizes
         __snake_case								=       depths
         __snake_case								=       layer_type
         __snake_case								=       hidden_act
         __snake_case								=       downsample_in_first_stage
         __snake_case								=       ['''stem'''] + [f"""stage{idx}""" for idx in range(1    ,      len(a__				) + 1				)]
         __snake_case	,     __snake_case								=       get_aligned_output_features_output_indices(
             out_features=a__    ,      out_indices=a__    ,      stage_names=self.stage_names				)






class 		SCREAMING_SNAKE_CASE__    (	_UpperCAmelCase  ):
      A_						:    int							=   version.parse('1.11'  )


      @property
      def        a			(self	:				Any				):





         """simple docstring"""



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


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





         """simple docstring"""



         return 1E-3








from __future__ import annotations

snake_case_           =      [True] * 1000001
snake_case_           =      2
while i * i <= 1000000:
    if seive[i]:
        for j in range(i * i, 1000001, i):
            snake_case_           =      False
    i += 1






def lowerCamelCase__   (							snake_case_     :  int	)				->    bool:
   return seive[n]






def lowerCamelCase__   (							snake_case_     :  int	)				->    bool:
   return any(digit in '''02468''' for digit in str(snake_case_	)	)






def lowerCamelCase__   (							snake_case_     :  int = 100_0000	)				->    list[int]:
   __snake_case								=       [2]  # result already includes the number 2.
   for num in range(3	,				limit + 1	,				2	):
      if is_prime(snake_case_	) and not contains_an_even_digit(snake_case_	):
         __snake_case								=       str(snake_case_	)
         __snake_case								=       [int(str_num[j:] + str_num[:j]	) for j in range(len(snake_case_	)	)]
         if all(is_prime(snake_case_	) for i in list_nums	):
            result.append(snake_case_	)
   return result






def lowerCamelCase__   (							)				->    int:
   return len(find_circular_primes()	)


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

