


'''simple docstring'''



from collections import OrderedDict
from typing import List, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__UpperCAmelCase    :str				       =     logging.get_logger(__name__)

__UpperCAmelCase    :Tuple				       =     {
    "google/efficientnet-b7": "https://huggingface.co/google/efficientnet-b7/resolve/main/config.json",
}



class 			a       (	_a ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE :				Optional[int]							     =     "efficientnet"

     def __init__(       self  :	str							,				snake_case  :	int = 3							,				snake_case  :	int = 600							,				snake_case  :	float = 2.0							,				snake_case  :	float = 3.1							,				snake_case  :	int = 8							,				snake_case  :	List[int] = [3, 3, 5, 3, 5, 5, 3]							,				snake_case  :	List[int] = [32, 16, 24, 40, 80, 112, 192]							,				snake_case  :	List[int] = [16, 24, 40, 80, 112, 192, 320]							,				snake_case  :	List[int] = []							,				snake_case  :	List[int] = [1, 2, 2, 2, 1, 2, 1]							,				snake_case  :	List[int] = [1, 2, 2, 3, 3, 4, 1]							,				snake_case  :	List[int] = [1, 6, 6, 6, 6, 6, 6]							,				snake_case  :	float = 0.25							,				snake_case  :	str = "swish"							,				snake_case  :	int = 2560							,				snake_case  :	str = "mean"							,				snake_case  :	float = 0.02							,				snake_case  :	float = 0.001							,				snake_case  :	float = 0.99							,				snake_case  :	float = 0.5							,				snake_case  :	float = 0.2							,				**snake_case  :	Union[str, Any]							,				)		->							List[Any]:
          super().__init__(**snake_case    )

          __UpperCAmelCase			:				str													=    num_channels
          __UpperCAmelCase			:				int													=    image_size
          __UpperCAmelCase			:				List[Any]													=    width_coefficient
          __UpperCAmelCase			:				Any													=    depth_coefficient
          __UpperCAmelCase			:				List[Any]													=    depth_divisor
          __UpperCAmelCase			:				Any													=    kernel_sizes
          __UpperCAmelCase			:				List[str]													=    in_channels
          __UpperCAmelCase			:				Dict													=    out_channels
          __UpperCAmelCase			:				List[str]													=    depthwise_padding
          __UpperCAmelCase			:				Any													=    strides
          __UpperCAmelCase			:				Optional[Any]													=    num_block_repeats
          __UpperCAmelCase			:				Dict													=    expand_ratios
          __UpperCAmelCase			:				List[str]													=    squeeze_expansion_ratio
          __UpperCAmelCase			:				int													=    hidden_act
          __UpperCAmelCase			:				List[str]													=    hidden_dim
          __UpperCAmelCase			:				Union[str, Any]													=    pooling_type
          __UpperCAmelCase			:				Dict													=    initializer_range
          __UpperCAmelCase			:				str													=    batch_norm_eps
          __UpperCAmelCase			:				List[Any]													=    batch_norm_momentum
          __UpperCAmelCase			:				Any													=    dropout_rate
          __UpperCAmelCase			:				Tuple													=    drop_connect_rate
          __UpperCAmelCase			:				List[str]													=    sum(snake_case    ) * 4



class 			a       (	_a ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE :				Any							     =     version.parse("1.11" )

     @property
     def 				lowerCamelCase__				(       self  :	List[str]    )		->							Mapping[str, Mapping[int, str]]:
          return OrderedDict(
              [
                  ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
              ]    )






     @property
     def 				lowerCamelCase__				(       self  :	str    )		->							float:
          return 1E-5



'''simple docstring'''



def 			_a			(		_lowercase      :			int = 50000000						):





     '''simple docstring'''






     __UpperCAmelCase			:				List[str]													=    set()
     __UpperCAmelCase			:				Tuple													=    int((limit - 24) ** (1 / 2)						)

     __UpperCAmelCase			:				Tuple													=    set(range(3    ,      prime_square_limit + 1    ,      2						)						)
     primes.add(2						)
     for p in range(3    ,      prime_square_limit + 1    ,      2						):
          if p not in primes:
               continue
          primes.difference_update(set(range(p * p    ,      prime_square_limit + 1    ,      _lowercase						)						)						)

     for primea in primes:
          __UpperCAmelCase			:				Any													=    primea * primea
          for primea in primes:
               __UpperCAmelCase			:				Any													=    primea * primea * primea
               if square + cube >= limit - 16:
                    break
               for primea in primes:
                    __UpperCAmelCase			:				Optional[Any]													=    primea * primea * primea * primea
                    __UpperCAmelCase			:				Union[str, Any]													=    square + cube + tetr
                    if total >= limit:
                         break
                    ret.add(_lowercase						)

     return len(_lowercase						)


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