






"""simple docstring"""



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

_lowerCAmelCase	:	Any				=      logging.get_logger(__name__)

_lowerCAmelCase	:	int				=      {
    """openai/whisper-base""": """https://huggingface.co/openai/whisper-base/resolve/main/config.json""",
}

# fmt: off
_lowerCAmelCase	:	Tuple				=      [
    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, 1_058, 1_220, 1_267, 1_279, 1_303, 1_343, 1_377,
    1_391, 1_635, 1_782, 1_875, 2_162, 2_361, 2_488, 3_467, 4_008, 4_211,
    4_600, 4_808, 5_299, 5_855, 6_329, 7_203, 9_609, 9_959, 10_563, 10_786,
    11_420, 11_709, 11_907, 13_163, 13_697, 13_700, 14_808, 15_306, 16_410, 16_791,
    17_992, 19_203, 19_510, 20_724, 22_305, 22_935, 27_007, 30_109, 30_420, 33_409,
    34_949, 40_283, 40_493, 40_549, 47_282, 49_146, 50_257, 50_359, 50_360, 50_361
]
_lowerCAmelCase	:	Dict				=      [
    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, 1_350, 1_853, 1_982, 2_460, 2_627,
    3_246, 3_253, 3_268, 3_536, 3_846, 3_961, 4_183, 4_667, 6_585, 6_647,
    7_273, 9_061, 9_383, 10_428, 10_929, 11_938, 12_033, 12_331, 12_562, 13_793,
    14_157, 14_635, 15_265, 15_618, 16_553, 16_604, 18_362, 18_956, 20_075, 21_675,
    22_520, 26_130, 26_161, 26_435, 28_279, 29_464, 31_650, 32_302, 32_470, 36_865,
    42_863, 47_425, 49_870, 50_254, 50_258, 50_360, 50_361, 50_362
]




class 			lowerCAmelCase__			(    __magic_name__   ):
   SCREAMING_SNAKE_CASE_    ='''whisper'''
   SCREAMING_SNAKE_CASE_    =['''past_key_values''']
   SCREAMING_SNAKE_CASE_    ={'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}
   def __init__(		self      :	Optional[Any]							,			snake_case__      :	List[Any]=5_1_8_6_5							,			snake_case__      :	Dict=8_0							,			snake_case__      :	Tuple=6							,			snake_case__      :	List[str]=4							,			snake_case__      :	Optional[int]=6							,			snake_case__      :	Tuple=4							,			snake_case__      :	List[Any]=1_5_3_6							,			snake_case__      :	Tuple=1_5_3_6							,			snake_case__      :	Optional[Any]=0.0							,			snake_case__      :	Union[str, Any]=0.0							,			snake_case__      :	List[Any]=5_0_2_5_7							,			snake_case__      :	List[str]=True							,			snake_case__      :	Optional[Any]=True							,			snake_case__      :	Union[str, Any]="gelu"							,			snake_case__      :	int=2_5_6							,			snake_case__      :	Optional[Any]=0.0							,			snake_case__      :	List[Any]=0.0							,			snake_case__      :	int=0.0							,			snake_case__      :	Dict=0.02							,			snake_case__      :	Dict=False							,			snake_case__      :	List[Any]=1_5_0_0							,			snake_case__      :	str=4_4_8							,			snake_case__      :	Any=5_0_2_5_6							,			snake_case__      :	Tuple=5_0_2_5_6							,			snake_case__      :	Union[str, Any]=5_0_2_5_6							,			snake_case__      :	Optional[int]=None							,			snake_case__      :	str=[2_2_0, 5_0_2_5_6]							,			snake_case__      :	int=False							,			snake_case__      :	Optional[int]=2_5_6							,			snake_case__      :	Tuple=False							,			snake_case__      :	List[Any]=0.05							,			snake_case__      :	List[Any]=1_0							,			snake_case__      :	int=2							,			snake_case__      :	List[Any]=0.0							,			snake_case__      :	Optional[int]=1_0							,			snake_case__      :	Tuple=0							,			snake_case__      :	Optional[int]=7							,			**snake_case__      :	List[Any]							,			):


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

        # Audio Classification-specific parameters. Feel free to ignore for other classes.
        UpperCAmelCase__						:    Any							=							classifier_proj_size
        UpperCAmelCase__						:    List[Any]							=							use_weighted_layer_sum

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

        UpperCAmelCase__						:    Union[str, Any]							=							median_filter_width

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




class 			lowerCAmelCase__			(    __magic_name__   ):
   @property
   def       __a							(		self      :	List[Any]							):


        '''simple docstring'''
        UpperCAmelCase__						:    str							=							OrderedDict(
            [
                ("input_features", {0: "batch", 1: "feature_size", 2: "encoder_sequence"}),
            ]							)
        if self.use_past:
             UpperCAmelCase__						:    Dict							=							{0: "batch"}
        else:
             UpperCAmelCase__						:    Optional[int]							=							{0: "batch", 1: "decoder_sequence"}

        if self.use_past:
             self.fill_with_past_key_values_(snake_case__							,			direction="inputs"							)

        return common_inputs
   def       __a							(		self      :	Optional[Any]							,			snake_case__      :	Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]							,			snake_case__      :	int = -1							,			snake_case__      :	int = -1							,			snake_case__      :	bool = False							,			snake_case__      :	Optional["TensorType"] = None							,			snake_case__      :	int = 2_2_0_5_0							,			snake_case__      :	float = 5.0							,			snake_case__      :	int = 2_2_0							,			):


        '''simple docstring'''
        UpperCAmelCase__						:    List[Any]							=							OrderedDict()
        UpperCAmelCase__						:    Any							=							OnnxConfig.generate_dummy_inputs(
            self							,			preprocessor=preprocessor.feature_extractor							,			batch_size=snake_case__							,			framework=snake_case__							,			sampling_rate=snake_case__							,			time_duration=snake_case__							,			frequency=snake_case__							,			)
        UpperCAmelCase__						:    int							=							encoder_inputs["input_features"].shape[2]
        UpperCAmelCase__						:    Union[str, Any]							=							encoder_sequence_length // 2 if self.use_past else seq_length

        UpperCAmelCase__						:    Tuple							=							super().generate_dummy_inputs(
            preprocessor.tokenizer							,			snake_case__							,			snake_case__							,			snake_case__							,			snake_case__							)

        UpperCAmelCase__						:    Dict							=							encoder_inputs.pop("input_features"							)
        UpperCAmelCase__						:    str							=							decoder_inputs.pop("decoder_input_ids"							)

        if "past_key_values" in decoder_inputs:
             UpperCAmelCase__						:    Any							=							decoder_inputs.pop("past_key_values"							)

        return dummy_inputs




   @property
   def       __a							(		self      :	List[Any]							):


        '''simple docstring'''
        return 1e-3










"""simple docstring"""



import os


def 	SCREAMING_SNAKE_CASE__       (  )->		Optional[Any]:






     '''simple docstring'''



     with open(os.path.dirname(snake_case				) + "/p022_names.txt"				) as file:
          UpperCAmelCase__						:    Tuple							=							str(file.readlines()[0]				)
          UpperCAmelCase__						:    str							=							names.replace("\""			,					""				).split(","				)

     names.sort()

     UpperCAmelCase__						:    Optional[int]							=							0
     UpperCAmelCase__						:    List[str]							=							0

     for i, name in enumerate(snake_case				):
          for letter in name:
               name_score += ord(snake_case				) - 64

          total_score += (i + 1) * name_score
          UpperCAmelCase__						:    Optional[int]							=							0
     return total_score


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


