


"""simple docstring"""



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


__snake_case   			=    logging.get_logger(__name__)

__snake_case   			=    {
    """facebook/data2vec-vision-base-ft""": (
        """https://huggingface.co/facebook/data2vec-vision-base-ft/resolve/main/config.json"""
    ),
}







class _lowerCAmelCase				(      snake_case_	):
   __UpperCAmelCase :       List[Any]							  =  "data2vec-vision"







   def __init__(	self						,	UpperCamelCase__=768						,	UpperCamelCase__=12						,	UpperCamelCase__=12						,	UpperCamelCase__=3072						,	UpperCamelCase__="gelu"						,	UpperCamelCase__=0.0						,	UpperCamelCase__=0.0						,	UpperCamelCase__=0.02						,	UpperCamelCase__=1e-12						,	UpperCamelCase__=224						,	UpperCamelCase__=16						,	UpperCamelCase__=3						,	UpperCamelCase__=False						,	UpperCamelCase__=False						,	UpperCamelCase__=False						,	UpperCamelCase__=False						,	UpperCamelCase__=0.1						,	UpperCamelCase__=0.1						,	UpperCamelCase__=True						,	UpperCamelCase__=[3, 5, 7, 11]						,	UpperCamelCase__=[1, 2, 3, 6]						,	UpperCamelCase__=True						,	UpperCamelCase__=0.4						,	UpperCamelCase__=256						,	UpperCamelCase__=1						,	UpperCamelCase__=False						,	UpperCamelCase__=255						,	**UpperCamelCase__						,	)	->		Tuple:

       '''simple docstring'''




       super().__init__(**snake_case__						)

       snake_case    :      Tuple      					=    hidden_size
       snake_case    :      List[Any]      					=    num_hidden_layers
       snake_case    :      Tuple      					=    num_attention_heads
       snake_case    :      Optional[int]      					=    intermediate_size
       snake_case    :      Optional[int]      					=    hidden_act
       snake_case    :      Dict      					=    hidden_dropout_prob
       snake_case    :      Optional[Any]      					=    attention_probs_dropout_prob
       snake_case    :      int      					=    initializer_range
       snake_case    :      Dict      					=    layer_norm_eps

       snake_case    :      Optional[int]      					=    image_size
       snake_case    :      Optional[Any]      					=    patch_size
       snake_case    :      Optional[Any]      					=    num_channels
       snake_case    :      Union[str, Any]      					=    use_mask_token
       snake_case    :      str      					=    use_absolute_position_embeddings
       snake_case    :      Any      					=    use_relative_position_bias
       snake_case    :      List[str]      					=    use_shared_relative_position_bias
       snake_case    :      str      					=    layer_scale_init_value
       snake_case    :      Union[str, Any]      					=    drop_path_rate
       snake_case    :      Any      					=    use_mean_pooling
       # decode head attributes (semantic segmentation)
       snake_case    :      Optional[int]      					=    out_indices
       snake_case    :      Union[str, Any]      					=    pool_scales
       # auxiliary head attributes (semantic segmentation)
       snake_case    :      str      					=    use_auxiliary_head
       snake_case    :      int      					=    auxiliary_loss_weight
       snake_case    :      Tuple      					=    auxiliary_channels
       snake_case    :      List[str]      					=    auxiliary_num_convs
       snake_case    :      Tuple      					=    auxiliary_concat_input
       snake_case    :      List[str]      					=    semantic_loss_ignore_index







class _lowerCAmelCase				(      snake_case_	):
   __UpperCAmelCase :       Union[str, Any]							  =  version.parse('''1.11'''	)







   @property
   def  lowerCamelCase		(	self						)	->		Dict:

       '''simple docstring'''




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







   @property
   def  lowerCamelCase		(	self						)	->		int:

       '''simple docstring'''




       return 1e-4









"""simple docstring"""







from __future__ import annotations

from functools import lru_cache
from math import ceil

lowerCAmelCase__      				=   100

lowerCAmelCase__      				=   set(range(3, NUM_PRIMES, 2))
primes.add(2)
lowerCAmelCase__      				=   42

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
     if prime not in primes:
          continue
     primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))
@lru_cache(maxsize=1_0_0				)
def 					a__			(				SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  if number_to_partition < 0:
    return set()
  elif number_to_partition == 0:
    return {1}

  lowerCAmelCase     :     set[int]								=							set()
  lowerCAmelCase     :     int
  lowerCAmelCase     :     int

  for prime in primes:
    if prime > number_to_partition:
      continue
    for sub in partition(number_to_partition - prime				):
      ret.add(sub * prime				)

  return ret
def 					a__			(				SCREAMING_SNAKE_CASE    :    int = 5_0_0_0				):


  '''simple docstring'''







  for number_to_partition in range(1				,      SCREAMING_SNAKE_CASE				):
    if len(partition(SCREAMING_SNAKE_CASE				)				) > number_unique_partitions:
      return number_to_partition
  return None


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





