



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__  =			logging.get_logger(__name__)

UpperCAmelCase__  =			{
    "microsoft/deberta-base": "https://huggingface.co/microsoft/deberta-base/resolve/main/config.json",
    "microsoft/deberta-large": "https://huggingface.co/microsoft/deberta-large/resolve/main/config.json",
    "microsoft/deberta-xlarge": "https://huggingface.co/microsoft/deberta-xlarge/resolve/main/config.json",
    "microsoft/deberta-base-mnli": "https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/config.json",
    "microsoft/deberta-large-mnli": "https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/config.json",
    "microsoft/deberta-xlarge-mnli": "https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/config.json",
}







class      __lowerCAmelCase       (     A		):
			UpperCamelCase     =	'''deberta'''



			def __init__(		self  :    Dict					,						A  :    Dict=5_02_65					,						A  :    Tuple=7_68					,						A  :    str=12					,						A  :    Any=12					,						A  :    Any=30_72					,						A  :    Dict="gelu"					,						A  :    int=0.1					,						A  :    Union[str, Any]=0.1					,						A  :    Tuple=5_12					,						A  :    Optional[Any]=0					,						A  :    int=0.0_2					,						A  :    Optional[Any]=1E-7					,						A  :    Any=False					,						A  :    Union[str, Any]=-1					,						A  :    Any=0					,						A  :    List[str]=True					,						A  :    Any=None					,						A  :    Dict=0					,						A  :    List[Any]="gelu"					,						**A  :    List[Any]					,						)  ->       Tuple:



						"""simple docstring"""






						super().__init__(**A)

						_UpperCAmelCase									=  hidden_size
						_UpperCAmelCase									=  num_hidden_layers
						_UpperCAmelCase									=  num_attention_heads
						_UpperCAmelCase									=  intermediate_size
						_UpperCAmelCase									=  hidden_act
						_UpperCAmelCase									=  hidden_dropout_prob
						_UpperCAmelCase									=  attention_probs_dropout_prob
						_UpperCAmelCase									=  max_position_embeddings
						_UpperCAmelCase									=  type_vocab_size
						_UpperCAmelCase									=  initializer_range
						_UpperCAmelCase									=  relative_attention
						_UpperCAmelCase									=  max_relative_positions
						_UpperCAmelCase									=  pad_token_id
						_UpperCAmelCase									=  position_biased_input

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

						_UpperCAmelCase									=  pos_att_type
						_UpperCAmelCase									=  vocab_size
						_UpperCAmelCase									=  layer_norm_eps

						_UpperCAmelCase									=  kwargs.get('pooler_hidden_size'					,						A)
						_UpperCAmelCase									=  pooler_dropout
						_UpperCAmelCase									=  pooler_hidden_act







class      __lowerCAmelCase       (     A		):



			@property
			def        _lowerCamelCase			(		self  :    Dict)  ->       Mapping[str, Mapping[int, str]]:



						"""simple docstring"""






						if self.task == "multiple-choice":
									_UpperCAmelCase									=  {0: 'batch', 1: 'choice', 2: 'sequence'}
						else:
									_UpperCAmelCase									=  {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  :    List[str])  ->       int:



						"""simple docstring"""






						return 12



			def        _lowerCamelCase			(		self  :    str					,						A  :    Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]					,						A  :    int = -1					,						A  :    int = -1					,						A  :    int = -1					,						A  :    bool = False					,						A  :    Optional["TensorType"] = None					,						A  :    int = 3					,						A  :    int = 40					,						A  :    int = 40					,						A  :    "PreTrainedTokenizerBase" = None					,						)  ->       Mapping[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase									=  super().generate_dummy_inputs(preprocessor=A					,						framework=A)
						if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
									del dummy_inputs["token_type_ids"]
						return dummy_inputs





import math





def 				A      (	_UpperCAmelCase							:  int       )							->					int:







			'''simple docstring'''
			return sum(int(_UpperCAmelCase       ) for digit in str(_UpperCAmelCase       )       )





def 				A      (	_UpperCAmelCase							:  int = 30       )							->					int:







			'''simple docstring'''
			_UpperCAmelCase									=  []
			for digit in range(2				,  100       ):
						for power in range(2				,  100       ):
									_UpperCAmelCase									=  int(math.pow(_UpperCAmelCase				,  _UpperCAmelCase       )       )
									if digit == digit_sum(_UpperCAmelCase       ):
												digit_to_powers.append(_UpperCAmelCase       )

			digit_to_powers.sort()
			return digit_to_powers[n - 1]


if __name__ == "__main__":
							print(solution())
