


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

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

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

# fmt: off
SCREAMING_SNAKE_CASE__					:     List[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, 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
]
SCREAMING_SNAKE_CASE__					:     str       =     [
    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 		_SCREAMING_SNAKE_CASE     (						A     ):
     __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							,					A_=5_18_65							,					A_=80							,					A_=6							,					A_=4							,					A_=6							,					A_=4							,					A_=15_36							,					A_=15_36							,					A_=0.0							,					A_=0.0							,					A_=5_02_57							,					A_=True							,					A_=True							,					A_="gelu"							,					A_=2_56							,					A_=0.0							,					A_=0.0							,					A_=0.0							,					A_=0.0_2							,					A_=False							,					A_=15_00							,					A_=4_48							,					A_=5_02_56							,					A_=5_02_56							,					A_=5_02_56							,					A_=None							,					A_=[2_20, 5_02_56]							,					A_=False							,					A_=2_56							,					A_=False							,					A_=0.0_5							,					A_=10							,					A_=2							,					A_=0.0							,					A_=10							,					A_=0							,					A_=7							,					**A_							,					):
       _UpperCAmelCase		:							Tuple							=     vocab_size
       _UpperCAmelCase		:							str							=     num_mel_bins
       _UpperCAmelCase		:							Dict							=     d_model
       _UpperCAmelCase		:							Optional[Any]							=     encoder_layers
       _UpperCAmelCase		:							str							=     encoder_attention_heads
       _UpperCAmelCase		:							Dict							=     decoder_layers
       _UpperCAmelCase		:							List[Any]							=     decoder_attention_heads
       _UpperCAmelCase		:							List[str]							=     decoder_ffn_dim
       _UpperCAmelCase		:							Union[str, Any]							=     encoder_ffn_dim
       _UpperCAmelCase		:							Any							=     dropout
       _UpperCAmelCase		:							Dict							=     attention_dropout
       _UpperCAmelCase		:							Optional[int]							=     activation_dropout
       _UpperCAmelCase		:							str							=     activation_function
       _UpperCAmelCase		:							Tuple							=     init_std
       _UpperCAmelCase		:							int							=     encoder_layerdrop
       _UpperCAmelCase		:							List[Any]							=     decoder_layerdrop
       _UpperCAmelCase		:							Optional[Any]							=     use_cache
       _UpperCAmelCase		:							List[Any]							=     encoder_layers
       _UpperCAmelCase		:							Any							=     scale_embedding  # scale factor will be sqrt(d_model) if True
       _UpperCAmelCase		:							Tuple							=     max_source_positions
       _UpperCAmelCase		:							Optional[int]							=     max_target_positions

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

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

       _UpperCAmelCase		:							Optional[Any]							=     median_filter_width

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


class 		_SCREAMING_SNAKE_CASE     (						A     ):


     @property
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[Any]							=     OrderedDict(
           [
               ("""input_features""", {0: """batch""", 1: """feature_size""", 2: """encoder_sequence"""}),
           ]    )
       if self.use_past:
         _UpperCAmelCase		:							str							=     {0: """batch"""}
       else:
         _UpperCAmelCase		:							Optional[int]							=     {0: """batch""", 1: """decoder_sequence"""}

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

       return common_inputs


     def        __snake_case(  self							,					A_							,					A_ = -1							,					A_ = -1							,					A_ = False							,					A_ = None							,					A_ = 2_20_50							,					A_ = 5.0							,					A_ = 2_20							,					):
       _UpperCAmelCase		:							int							=     OrderedDict()
       _UpperCAmelCase		:							Any							=     OnnxConfig.generate_dummy_inputs(
           self							,					preprocessor=preprocessor.feature_extractor							,					batch_size=A_							,					framework=A_							,					sampling_rate=A_							,					time_duration=A_							,					frequency=A_							,					)
       _UpperCAmelCase		:							List[str]							=     encoder_inputs["""input_features"""].shape[2]
       _UpperCAmelCase		:							Optional[Any]							=     encoder_sequence_length // 2 if self.use_past else seq_length

       _UpperCAmelCase		:							str							=     super().generate_dummy_inputs(
           preprocessor.tokenizer							,					A_							,					A_							,					A_							,					A_    )

       _UpperCAmelCase		:							str							=     encoder_inputs.pop("""input_features"""    )
       _UpperCAmelCase		:							Optional[int]							=     decoder_inputs.pop("""decoder_input_ids"""    )

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

       return dummy_inputs




     @property
     def        __snake_case(  self    ):
       return 1e-3









from __future__ import annotations




def    a__    (		snake_case__					:							list[int]     ):
  if len(snake_case__     ) == 0:
    return array

  _UpperCAmelCase,_UpperCAmelCase		:							List[str]							=     min(snake_case__     ), max(snake_case__     )

  # Compute the variables
  _UpperCAmelCase		:							Tuple							=     _max - _min + 1
  _UpperCAmelCase,_UpperCAmelCase		:							Union[str, Any]							=     [0] * holes_range, [0] * holes_range

  # Make the sorting.
  for i in array:
    _UpperCAmelCase		:							Optional[int]							=     i - _min
    _UpperCAmelCase		:							Any							=     i
    holes_repeat[index] += 1

  # Makes the array back by replacing the numbers.
  _UpperCAmelCase		:							List[Any]							=     0
  for i in range(snake_case__     ):
    while holes_repeat[i] > 0:
      _UpperCAmelCase		:							Optional[Any]							=     holes[i]
      index += 1
      holes_repeat[i] -= 1

    # Returns the sorted array.
  return array


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 SCREAMING_SNAKE_CASE__					:     Dict       =     input('Enter numbers separated by comma:\n')
 SCREAMING_SNAKE_CASE__					:     Optional[int]       =     [int(x) for x in user_input.split(',')]
 print(pigeon_sort(unsorted))





