





import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


lowercase    : Optional[Any]    	=  logging.get_logger(__name__)

lowercase    : List[str]    	=  {
    """ut/deta""": """https://huggingface.co/ut/deta/resolve/main/config.json""",
}

class  __A(						__UpperCAmelCase ):
     __A	  =       "deta"
     __A	  =       {
         "hidden_size": "d_model",
         "num_attention_heads": "encoder_attention_heads",
     }

     def __init__(      self,       A=None,       A=900,       A=2048,       A=6,       A=2048,       A=8,       A=6,       A=1024,       A=8,       A=0.0,       A=True,       A="relu",       A=256,       A=0.1,       A=0.0,       A=0.0,       A=0.02,       A=1.0,       A=True,       A=False,       A="sine",       A=5,       A=4,       A=4,       A=True,       A=300,       A=True,       A=True,       A=1,       A=5,       A=2,       A=1,       A=1,       A=5,       A=2,       A=0.1,       A=0.25,       **A,       ):





            """simple docstring"""

            if backbone_config is None:
                   logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''      )
                   _UpperCamelCase              =						CONFIG_MAPPING['''resnet'''](out_features=['''stage2''', '''stage3''', '''stage4''']      )
            else:
                   if isinstance(A,       A      ):
                          _UpperCamelCase              =						backbone_config.pop('''model_type'''      )
                          _UpperCamelCase              =						CONFIG_MAPPING[backbone_model_type]
                          _UpperCamelCase              =						config_class.from_dict(A      )

            _UpperCamelCase              =						backbone_config
            _UpperCamelCase              =						num_queries
            _UpperCamelCase              =						max_position_embeddings
            _UpperCamelCase              =						d_model
            _UpperCamelCase              =						encoder_ffn_dim
            _UpperCamelCase              =						encoder_layers
            _UpperCamelCase              =						encoder_attention_heads
            _UpperCamelCase              =						decoder_ffn_dim
            _UpperCamelCase              =						decoder_layers
            _UpperCamelCase              =						decoder_attention_heads
            _UpperCamelCase              =						dropout
            _UpperCamelCase              =						attention_dropout
            _UpperCamelCase              =						activation_dropout
            _UpperCamelCase              =						activation_function
            _UpperCamelCase              =						init_std
            _UpperCamelCase              =						init_xavier_std
            _UpperCamelCase              =						encoder_layerdrop
            _UpperCamelCase              =						auxiliary_loss
            _UpperCamelCase              =						position_embedding_type
            # deformable attributes
            _UpperCamelCase              =						num_feature_levels
            _UpperCamelCase              =						encoder_n_points
            _UpperCamelCase              =						decoder_n_points
            _UpperCamelCase              =						two_stage
            _UpperCamelCase              =						two_stage_num_proposals
            _UpperCamelCase              =						with_box_refine
            _UpperCamelCase              =						assign_first_stage
            if two_stage is True and with_box_refine is False:
                   raise ValueError('''If two_stage is True, with_box_refine must be True.'''      )
            # Hungarian matcher
            _UpperCamelCase              =						class_cost
            _UpperCamelCase              =						bbox_cost
            _UpperCamelCase              =						giou_cost
            # Loss coefficients
            _UpperCamelCase              =						mask_loss_coefficient
            _UpperCamelCase              =						dice_loss_coefficient
            _UpperCamelCase              =						bbox_loss_coefficient
            _UpperCamelCase              =						giou_loss_coefficient
            _UpperCamelCase              =						eos_coefficient
            _UpperCamelCase              =						focal_alpha
            super().__init__(is_encoder_decoder=A,       **A      )

     @property
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            return self.encoder_attention_heads

     @property
     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            return self.d_model



     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						copy.deepcopy(self.__dict__      )
            _UpperCamelCase              =						self.backbone_config.to_dict()
            _UpperCamelCase              =						self.__class__.model_type
            return output













from __future__ import annotations

import math


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):

       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(math.sqrt(lowerCAmelCase					) + 1					)    ,       6					):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True


lowercase    : Tuple    	=  [num for num in range(3, 10_0001, 2) if not is_prime(num)]


def     SCREAMING_SNAKE_CASE			(      lowerCAmelCase					):
       if not isinstance(lowerCAmelCase    ,       lowerCAmelCase					):
              raise ValueError('''n must be an integer'''					)
       if n <= 0:
              raise ValueError('''n must be >= 0'''					)

       _UpperCamelCase              =						[]
       for num in range(len(lowerCAmelCase					)					):
              _UpperCamelCase              =						0
              while 2 * i * i <= odd_composites[num]:
                     _UpperCamelCase              =						odd_composites[num] - 2 * i * i
                     if is_prime(lowerCAmelCase					):
                            break
                     i += 1
              else:
                     list_nums.append(odd_composites[num]					)
                     if len(lowerCAmelCase					) == n:
                            return list_nums

       return []


def     SCREAMING_SNAKE_CASE			(      ):
       return compute_nums(1					)[0]


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






