


'''simple docstring'''



from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

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


if TYPE_CHECKING:
      from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


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

__UpperCAmelCase    :Union[str, Any]				       =     {
    "microsoft/deberta-v2-xlarge": "https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json",
    "microsoft/deberta-v2-xxlarge": "https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json",
    "microsoft/deberta-v2-xlarge-mnli": (
        "https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json"
    ),
    "microsoft/deberta-v2-xxlarge-mnli": (
        "https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json"
    ),
}



class 			a       (	_a ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE :				List[str]							     =     "deberta-v2"

     def __init__(       self  :	List[str]							,				snake_case  :	List[str]=12_8100							,				snake_case  :	str=1536							,				snake_case  :	int=24							,				snake_case  :	Union[str, Any]=24							,				snake_case  :	Union[str, Any]=6144							,				snake_case  :	Optional[Any]="gelu"							,				snake_case  :	int=0.1							,				snake_case  :	Tuple=0.1							,				snake_case  :	str=512							,				snake_case  :	Optional[int]=0							,				snake_case  :	int=0.02							,				snake_case  :	List[Any]=1E-7							,				snake_case  :	List[str]=False							,				snake_case  :	Union[str, Any]=-1							,				snake_case  :	Any=0							,				snake_case  :	Tuple=True							,				snake_case  :	Optional[int]=None							,				snake_case  :	str=0							,				snake_case  :	str="gelu"							,				**snake_case  :	Any							,				)		->							Optional[int]:
          super().__init__(**snake_case    )

          __UpperCAmelCase			:				Optional[Any]													=    hidden_size
          __UpperCAmelCase			:				Optional[Any]													=    num_hidden_layers
          __UpperCAmelCase			:				Optional[Any]													=    num_attention_heads
          __UpperCAmelCase			:				Union[str, Any]													=    intermediate_size
          __UpperCAmelCase			:				Union[str, Any]													=    hidden_act
          __UpperCAmelCase			:				Tuple													=    hidden_dropout_prob
          __UpperCAmelCase			:				Optional[int]													=    attention_probs_dropout_prob
          __UpperCAmelCase			:				List[Any]													=    max_position_embeddings
          __UpperCAmelCase			:				int													=    type_vocab_size
          __UpperCAmelCase			:				Optional[int]													=    initializer_range
          __UpperCAmelCase			:				Dict													=    relative_attention
          __UpperCAmelCase			:				str													=    max_relative_positions
          __UpperCAmelCase			:				int													=    pad_token_id
          __UpperCAmelCase			:				Union[str, Any]													=    position_biased_input

          # Backwards compatibility
          if type(snake_case    ) == str:
               __UpperCAmelCase			:				List[str]													=    [x.strip() for x in pos_att_type.lower().split('''|'''    )]

          __UpperCAmelCase			:				Tuple													=    pos_att_type
          __UpperCAmelCase			:				List[str]													=    vocab_size
          __UpperCAmelCase			:				str													=    layer_norm_eps

          __UpperCAmelCase			:				Union[str, Any]													=    kwargs.get('''pooler_hidden_size'''							,				snake_case    )
          __UpperCAmelCase			:				List[Any]													=    pooler_dropout
          __UpperCAmelCase			:				List[str]													=    pooler_hidden_act



class 			a       (	_a ):


     """simple docstring"""






     @property
     def 				lowerCamelCase__				(       self  :	str    )		->							Mapping[str, Mapping[int, str]]:
          if self.task == "multiple-choice":
               __UpperCAmelCase			:				str													=    {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
          else:
               __UpperCAmelCase			:				Any													=    {0: '''batch''', 1: '''sequence'''}
          if self._config.type_vocab_size > 0:
               return OrderedDict(
                   [('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis), ('''token_type_ids''', dynamic_axis)]    )
          else:
               return OrderedDict([('''input_ids''', dynamic_axis), ('''attention_mask''', dynamic_axis)]    )

     @property
     def 				lowerCamelCase__				(       self  :	Optional[int]    )		->							int:
          return 12






     def 				lowerCamelCase__				(       self  :	Optional[Any]							,				snake_case  :	Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]							,				snake_case  :	int = -1							,				snake_case  :	int = -1							,				snake_case  :	int = -1							,				snake_case  :	bool = False							,				snake_case  :	Optional["TensorType"] = None							,				snake_case  :	int = 3							,				snake_case  :	int = 40							,				snake_case  :	int = 40							,				snake_case  :	"PreTrainedTokenizerBase" = None							,				)		->							Mapping[str, Any]:
          __UpperCAmelCase			:				Tuple													=    super().generate_dummy_inputs(preprocessor=snake_case							,				framework=snake_case    )
          if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
               del dummy_inputs["token_type_ids"]
          return dummy_inputs



'''simple docstring'''



from __future__ import annotations




def 			_a			(		_lowercase      :			int						):





     '''simple docstring'''






     __UpperCAmelCase			:				str													=    [True] * limit
     __UpperCAmelCase			:				Tuple													=    False
     __UpperCAmelCase			:				List[str]													=    False
     __UpperCAmelCase			:				List[Any]													=    True

     for i in range(3    ,      int(limit**0.5 + 1						)    ,      2						):
          __UpperCAmelCase			:				Dict													=    i * 2
          while index < limit:
               __UpperCAmelCase			:				Optional[int]													=    False
               __UpperCAmelCase			:				Union[str, Any]													=    index + i

     __UpperCAmelCase			:				Optional[Any]													=    [2]

     for i in range(3    ,      _lowercase    ,      2						):
          if is_prime[i]:
               primes.append(_lowercase						)

     return primes




def 			_a			(		_lowercase      :			int = 1000000						):





     '''simple docstring'''






     __UpperCAmelCase			:				List[str]													=    prime_sieve(_lowercase						)
     __UpperCAmelCase			:				Optional[Any]													=    0
     __UpperCAmelCase			:				int													=    0

     for i in range(len(_lowercase						)						):
          for j in range(i + length    ,      len(_lowercase						)						):
               __UpperCAmelCase			:				Optional[Any]													=    sum(primes[i:j]						)
               if sol >= ceiling:
                    break

               if sol in primes:
                    __UpperCAmelCase			:				Any													=    j - i
                    __UpperCAmelCase			:				List[Any]													=    sol

     return largest


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