'''simple docstring'''




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig


_lowercase						: List[str]						=						{
    "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/config.json",
    "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/config.json",
    "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/config.json",
    "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json",
    "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/config.json",
    "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/config.json",
    "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/config.json",
    "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json",
}





class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''albert'''







			def __init__(	self				:  List[Any]				,			lowercase_				:  int=30000				,			lowercase_				:  Union[str, Any]=128				,			lowercase_				:  List[Any]=4096				,			lowercase_				:  List[Any]=12				,			lowercase_				:  Any=1				,			lowercase_				:  List[str]=64				,			lowercase_				:  Tuple=16384				,			lowercase_				:  str=1				,			lowercase_				:  Optional[Any]="gelu_new"				,			lowercase_				:  str=0				,			lowercase_				:  List[Any]=0				,			lowercase_				:  Optional[int]=512				,			lowercase_				:  Dict=2				,			lowercase_				:  Optional[Any]=0.02				,			lowercase_				:  Tuple=1E-12				,			lowercase_				:  List[Any]=0.1				,			lowercase_				:  List[Any]="absolute"				,			lowercase_				:  Tuple=0				,			lowercase_				:  str=2				,			lowercase_				:  List[str]=3				,			**lowercase_				:  Dict				,			):
										super().__init__(pad_token_id=lowercase_				,			bos_token_id=lowercase_				,			eos_token_id=lowercase_				,			**lowercase_    )

										lowercase_					:			Union[str, Any]										=       vocab_size
										lowercase_					:			Tuple										=       embedding_size
										lowercase_					:			Optional[int]										=       hidden_size
										lowercase_					:			str										=       num_hidden_layers
										lowercase_					:			Optional[int]										=       num_hidden_groups
										lowercase_					:			Tuple										=       num_attention_heads
										lowercase_					:			Union[str, Any]										=       inner_group_num
										lowercase_					:			Tuple										=       hidden_act
										lowercase_					:			Union[str, Any]										=       intermediate_size
										lowercase_					:			Tuple										=       hidden_dropout_prob
										lowercase_					:			Union[str, Any]										=       attention_probs_dropout_prob
										lowercase_					:			Union[str, Any]										=       max_position_embeddings
										lowercase_					:			Any										=       type_vocab_size
										lowercase_					:			Dict										=       initializer_range
										lowercase_					:			List[str]										=       layer_norm_eps
										lowercase_					:			Tuple										=       classifier_dropout_prob
										lowercase_					:			Tuple										=       position_embedding_type





class     __magic_name__						(    _UpperCAmelCase):







			@property
			def 	SCREAMING_SNAKE_CASE_     (	self				:  Union[str, Any]    ):
										if self.task == "multiple-choice":
																	lowercase_					:			List[Any]										=       {0: """batch""", 1: """choice""", 2: """sequence"""}
										else:
																	lowercase_					:			Dict										=       {0: """batch""", 1: """sequence"""}
										return OrderedDict(
										    [
										        ("""input_ids""", dynamic_axis),
										        ("""attention_mask""", dynamic_axis),
										        ("""token_type_ids""", dynamic_axis),
										    ]    )






'''simple docstring'''




import math




def 							lowerCamelCase	(      UpperCAmelCase__       :					int )			->      int:

							if not isinstance(UpperCAmelCase__      ,      UpperCAmelCase__ ):
														lowercase_					:			List[Any]										=       F'''Input value of [number={number}] must be an integer'''
														raise TypeError(UpperCAmelCase__ )

							if number < 1:
														lowercase_					:			Tuple										=       F'''Input value of [number={number}] must be > 0'''
														raise ValueError(UpperCAmelCase__ )
							elif number == 1:
														return 3
							elif number == 2:
														return 5
							else:
														lowercase_					:			Union[str, Any]										=       int(math.log(number // 3      ,      2 ) ) + 2

														lowercase_					:			Any										=       [3, 5]
														lowercase_					:			List[Any]										=       2
														lowercase_					:			Optional[Any]										=       3
														for block in range(1      ,      UpperCAmelCase__ ):
																					for _ in range(UpperCAmelCase__ ):
																												proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1] )
																												proth_index += 1
																					increment *= 2

							return proth_list[number - 1]


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						for number in range(11):
												_lowercase						: Optional[Any]						=						0
												try:
																		_lowercase						: str						=						proth(number)
												except ValueError:
																		print(f"""ValueError: there is no {number}th Proth number""")
																		continue

												print(f"""The {number}th Proth number: {value}""")





