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

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


if TYPE_CHECKING:
					from ...feature_extraction_utils import FeatureExtractionMixin
					from ...tokenization_utils_base import PreTrainedTokenizerBase
					from ...utils import TensorType

__UpperCamelCase		:       List[str]									=     logging.get_logger(__name__)

__UpperCamelCase		:       str									=     {
    'openai/whisper-base': 'https://huggingface.co/openai/whisper-base/resolve/main/config.json',
}

# fmt: off
__UpperCamelCase		:       Optional[Any]									=     [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 357, 366, 438, 532, 685,
    705, 796, 930, 1058, 1220, 1267, 1279, 1303, 1343, 1377,
    1391, 1635, 1782, 1875, 2162, 2361, 2488, 3467, 4008, 4211,
    4600, 4808, 5299, 5855, 6329, 7203, 9609, 9959, 1_0563, 1_0786,
    1_1420, 1_1709, 1_1907, 1_3163, 1_3697, 1_3700, 1_4808, 1_5306, 1_6410, 1_6791,
    1_7992, 1_9203, 1_9510, 2_0724, 2_2305, 2_2935, 2_7007, 3_0109, 3_0420, 3_3409,
    3_4949, 4_0283, 4_0493, 4_0549, 4_7282, 4_9146, 5_0257, 5_0359, 5_0360, 5_0361
]
__UpperCamelCase		:       int									=     [
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 359, 503, 522, 542, 873,
    893, 902, 918, 922, 931, 1350, 1853, 1982, 2460, 2627,
    3246, 3253, 3268, 3536, 3846, 3961, 4183, 4667, 6585, 6647,
    7273, 9061, 9383, 1_0428, 1_0929, 1_1938, 1_2033, 1_2331, 1_2562, 1_3793,
    1_4157, 1_4635, 1_5265, 1_5618, 1_6553, 1_6604, 1_8362, 1_8956, 2_0075, 2_1675,
    2_2520, 2_6130, 2_6161, 2_6435, 2_8279, 2_9464, 3_1650, 3_2302, 3_2470, 3_6865,
    4_2863, 4_7425, 4_9870, 5_0254, 5_0258, 5_0360, 5_0361, 5_0362
]





class 					lowercase__						(   UpperCamelCase_):
						UpperCamelCase_     =		"""whisper"""
						UpperCamelCase_     =		["""past_key_values"""]
						UpperCamelCase_     =		{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}


						def __init__(       self	:				Optional[int]    ,		UpperCamelCase__	:				Optional[Any]=5_1865    ,		UpperCamelCase__	:				List[Any]=80    ,		UpperCamelCase__	:				Optional[Any]=6    ,		UpperCamelCase__	:				Tuple=4    ,		UpperCamelCase__	:				List[str]=6    ,		UpperCamelCase__	:				Union[str, Any]=4    ,		UpperCamelCase__	:				str=1536    ,		UpperCamelCase__	:				List[Any]=1536    ,		UpperCamelCase__	:				Any=0.0    ,		UpperCamelCase__	:				Tuple=0.0    ,		UpperCamelCase__	:				Dict=5_0257    ,		UpperCamelCase__	:				Optional[Any]=True    ,		UpperCamelCase__	:				Tuple=True    ,		UpperCamelCase__	:				Union[str, Any]="gelu"    ,		UpperCamelCase__	:				str=256    ,		UpperCamelCase__	:				Optional[Any]=0.0    ,		UpperCamelCase__	:				List[str]=0.0    ,		UpperCamelCase__	:				Tuple=0.0    ,		UpperCamelCase__	:				Tuple=0.02    ,		UpperCamelCase__	:				Dict=False    ,		UpperCamelCase__	:				List[str]=1500    ,		UpperCamelCase__	:				int=448    ,		UpperCamelCase__	:				Optional[Any]=5_0256    ,		UpperCamelCase__	:				int=5_0256    ,		UpperCamelCase__	:				Optional[int]=5_0256    ,		UpperCamelCase__	:				str=None    ,		UpperCamelCase__	:				Optional[Any]=[220, 5_0256]    ,		UpperCamelCase__	:				Optional[Any]=False    ,		UpperCamelCase__	:				str=256    ,		UpperCamelCase__	:				List[str]=False    ,		UpperCamelCase__	:				int=0.05    ,		UpperCamelCase__	:				List[str]=10    ,		UpperCamelCase__	:				int=2    ,		UpperCamelCase__	:				int=0.0    ,		UpperCamelCase__	:				List[str]=10    ,		UpperCamelCase__	:				Dict=0    ,		UpperCamelCase__	:				Dict=7    ,		**UpperCamelCase__	:				List[Any]    ,		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							vocab_size
												SCREAMING_SNAKE_CASE							:    int							=							num_mel_bins
												SCREAMING_SNAKE_CASE							:    Any							=							d_model
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							encoder_layers
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							encoder_attention_heads
												SCREAMING_SNAKE_CASE							:    int							=							decoder_layers
												SCREAMING_SNAKE_CASE							:    Any							=							decoder_attention_heads
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							decoder_ffn_dim
												SCREAMING_SNAKE_CASE							:    Tuple							=							encoder_ffn_dim
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							dropout
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							attention_dropout
												SCREAMING_SNAKE_CASE							:    str							=							activation_dropout
												SCREAMING_SNAKE_CASE							:    Any							=							activation_function
												SCREAMING_SNAKE_CASE							:    Dict							=							init_std
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							encoder_layerdrop
												SCREAMING_SNAKE_CASE							:    str							=							decoder_layerdrop
												SCREAMING_SNAKE_CASE							:    str							=							use_cache
												SCREAMING_SNAKE_CASE							:    Any							=							encoder_layers
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							scale_embedding  # scale factor will be sqrt(d_model) if True
												SCREAMING_SNAKE_CASE							:    str							=							max_source_positions
												SCREAMING_SNAKE_CASE							:    List[Any]							=							max_target_positions

												# Audio Classification-specific parameters. Feel free to ignore for other classes.
												SCREAMING_SNAKE_CASE							:    Tuple							=							classifier_proj_size
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							use_weighted_layer_sum

												# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							apply_spec_augment
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							mask_time_prob
												SCREAMING_SNAKE_CASE							:    Any							=							mask_time_length
												SCREAMING_SNAKE_CASE							:    List[str]							=							mask_time_min_masks
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							mask_feature_prob
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							mask_feature_length
												SCREAMING_SNAKE_CASE							:    int							=							mask_feature_min_masks

												SCREAMING_SNAKE_CASE							:    str							=							median_filter_width

												super().__init__(
												    pad_token_id=UpperCamelCase__    ,		bos_token_id=UpperCamelCase__    ,		eos_token_id=UpperCamelCase__    ,		is_encoder_decoder=UpperCamelCase__    ,		decoder_start_token_id=UpperCamelCase__    ,		suppress_tokens=UpperCamelCase__    ,		begin_suppress_tokens=UpperCamelCase__    ,		**UpperCamelCase__    ,		)






class 					lowercase__						(   UpperCamelCase_):


						@property
						def        __A       (       self	:				Dict						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							OrderedDict(
												    [
												        ('''input_features''', {0: '''batch''', 1: '''feature_size''', 2: '''encoder_sequence'''}),
												    ]						)
												if self.use_past:
																		SCREAMING_SNAKE_CASE							:    str							=							{0: '''batch'''}
												else:
																		SCREAMING_SNAKE_CASE							:    int							=							{0: '''batch''', 1: '''decoder_sequence'''}

												if self.use_past:
																		self.fill_with_past_key_values_(UpperCamelCase__    ,		direction='''inputs'''						)

												return common_inputs


						def        __A       (       self	:				Union[str, Any]    ,		UpperCamelCase__	:				Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]    ,		UpperCamelCase__	:				int = -1    ,		UpperCamelCase__	:				int = -1    ,		UpperCamelCase__	:				bool = False    ,		UpperCamelCase__	:				Optional["TensorType"] = None    ,		UpperCamelCase__	:				int = 2_2050    ,		UpperCamelCase__	:				float = 5.0    ,		UpperCamelCase__	:				int = 220    ,		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Optional[int]							=							OrderedDict()
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							OnnxConfig.generate_dummy_inputs(
												    self    ,		preprocessor=preprocessor.feature_extractor    ,		batch_size=UpperCamelCase__    ,		framework=UpperCamelCase__    ,		sampling_rate=UpperCamelCase__    ,		time_duration=UpperCamelCase__    ,		frequency=UpperCamelCase__    ,		)
												SCREAMING_SNAKE_CASE							:    Dict							=							encoder_inputs['''input_features'''].shape[2]
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							encoder_sequence_length // 2 if self.use_past else seq_length

												SCREAMING_SNAKE_CASE							:    Dict							=							super().generate_dummy_inputs(
												    preprocessor.tokenizer    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__    ,		UpperCamelCase__						)

												SCREAMING_SNAKE_CASE							:    List[Any]							=							encoder_inputs.pop('''input_features'''						)
												SCREAMING_SNAKE_CASE							:    Any							=							decoder_inputs.pop('''decoder_input_ids'''						)

												if "past_key_values" in decoder_inputs:
																		SCREAMING_SNAKE_CASE							:    Optional[Any]							=							decoder_inputs.pop('''past_key_values'''						)

												return dummy_inputs



						@property
						def        __A       (       self	:				Optional[Any]						):





												'''simple docstring'''





												return 1E-3






from math import ceil
def       A	(    _lowercase = 1_001						):
						SCREAMING_SNAKE_CASE							:    Any							=							1

						for i in range(1		,  int(ceil(n / 2.0						)						)						):
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							2 * i + 1
												SCREAMING_SNAKE_CASE							:    int							=							2 * i
												SCREAMING_SNAKE_CASE							:    List[str]							=							total + 4 * odd**2 - 6 * even

						return total


if __name__ == "__main__":
					import sys

					if len(sys.argv) == 1:
										print(solution())
					else:
										try:
															__UpperCamelCase		:       Dict									=     int(sys.argv[1])
															print(solution(n))
										except ValueError:
															print('Invalid entry - please enter a number')





