





'''simple docstring'''




import math







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase = 0       ,    _lowerCAmelCase = 0    )->     list:
 __UpperCAmelCase					=   end or len(_lowerCAmelCase    )
 for i in range(_lowerCAmelCase       ,    _lowerCAmelCase    ):
  __UpperCAmelCase					=   i
  __UpperCAmelCase					=   array[i]
  while temp_index != start and temp_index_value < array[temp_index - 1]:
   __UpperCAmelCase					=   array[temp_index - 1]
   temp_index -= 1
  __UpperCAmelCase					=   temp_index_value
 return array







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )->     None:  # Max Heap
 __UpperCAmelCase					=   index
 __UpperCAmelCase					=   2 * index + 1  # Left Node
 __UpperCAmelCase					=   2 * index + 2  # Right Node

 if left_index < heap_size and array[largest] < array[left_index]:
  __UpperCAmelCase					=   left_index

 if right_index < heap_size and array[largest] < array[right_index]:
  __UpperCAmelCase					=   right_index

 if largest != index:
  __UpperCAmelCase					,    __UpperCAmelCase					=   array[largest], array[index]
  heapify(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )







def _lowerCAmelCase     (      _lowerCAmelCase    )->     list:
 __UpperCAmelCase					=   len(_lowerCAmelCase    )

 for i in range(n // 2       ,    -1       ,    -1    ):
  heapify(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )

 for i in range(n - 1       ,    0       ,    -1    ):
  __UpperCAmelCase					,    __UpperCAmelCase					=   array[0], array[i]
  heapify(_lowerCAmelCase       ,    0       ,    _lowerCAmelCase    )

 return array







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )->     int:
 if (array[first_index] > array[middle_index]) != (
     array[first_index] > array[last_index]
 ):
  return array[first_index]
 elif (array[middle_index] > array[first_index]) != (
     array[middle_index] > array[last_index]
 ):
  return array[middle_index]
 else:
  return array[last_index]







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )->     int:
 __UpperCAmelCase					=   low
 __UpperCAmelCase					=   high
 while True:
  while array[i] < pivot:
   i += 1
  j -= 1
  while pivot < array[j]:
   j -= 1
  if i >= j:
   return i
  __UpperCAmelCase					,    __UpperCAmelCase					=   array[j], array[i]
  i += 1







def _lowerCAmelCase     (      _lowerCAmelCase    )->     list:
 if len(_lowerCAmelCase    ) == 0:
  return array
 __UpperCAmelCase					=   2 * math.ceil(math.loga(len(_lowerCAmelCase    )    )    )
 __UpperCAmelCase					=   16
 return intro_sort(_lowerCAmelCase       ,    0       ,    len(_lowerCAmelCase    )       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )->     list:
 while end - start > size_threshold:
  if max_depth == 0:
   return heap_sort(_lowerCAmelCase    )
  max_depth -= 1
  __UpperCAmelCase					=   median_of_a(_lowerCAmelCase       ,    _lowerCAmelCase       ,    start + ((end - start) // 2) + 1       ,    end - 1    )
  __UpperCAmelCase					=   partition(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )
  intro_sort(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )
  __UpperCAmelCase					=   p
 return insertion_sort(_lowerCAmelCase       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    _A:					Optional[Any]							=				input("""Enter numbers separated by a comma : """).strip()
    _A:					str							=				[float(item) for item in user_input.split(""",""")]
    print(sort(unsorted))












'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_A:					str							=				{
    """configuration_whisper""": ["""WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """WhisperConfig""", """WhisperOnnxConfig"""],
    """feature_extraction_whisper""": ["""WhisperFeatureExtractor"""],
    """processing_whisper""": ["""WhisperProcessor"""],
    """tokenization_whisper""": ["""WhisperTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Union[str, Any]							=				["""WhisperTokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Optional[Any]							=				[
        """WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """WhisperForConditionalGeneration""",
        """WhisperModel""",
        """WhisperPreTrainedModel""",
        """WhisperForAudioClassification""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Dict							=				[
        """TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFWhisperForConditionalGeneration""",
        """TFWhisperModel""",
        """TFWhisperPreTrainedModel""",
    ]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Union[str, Any]							=				[
        """FlaxWhisperForConditionalGeneration""",
        """FlaxWhisperModel""",
        """FlaxWhisperPreTrainedModel""",
        """FlaxWhisperForAudioClassification""",
    ]


if TYPE_CHECKING:
    from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
    from .feature_extraction_whisper import WhisperFeatureExtractor
    from .processing_whisper import WhisperProcessor
    from .tokenization_whisper import WhisperTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_whisper_fast import WhisperTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_whisper import (
            WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
            WhisperForAudioClassification,
            WhisperForConditionalGeneration,
            WhisperModel,
            WhisperPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_whisper import (
            TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFWhisperForConditionalGeneration,
            TFWhisperModel,
            TFWhisperPreTrainedModel,
        )

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_whisper import (
            FlaxWhisperForAudioClassification,
            FlaxWhisperForConditionalGeneration,
            FlaxWhisperModel,
            FlaxWhisperPreTrainedModel,
        )

else:
    import sys

    _A:					int							=				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





