






'''simple docstring'''





from typing import TYPE_CHECKING

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


_UpperCamelCase		:		Tuple            = {
    """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:
						_UpperCamelCase		:		Optional[int]            = ["""WhisperTokenizerFast"""]

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

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

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_UpperCamelCase		:		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

						_UpperCamelCase		:		Tuple            = _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




"""simple docstring"""




from __future__ import annotations

from bisect import bisect_left
from functools import total_ordering
from heapq import merge

@total_ordering
class 		a__						(      a_						):
   def __lt__(			self	,    _a				):
          return self[-1] < other[-1]

   def __eq__(			self	,    _a				):
          return self[-1] == other[-1]


def   __magic_name__	(      __snake_case				:       list  ) ->				list:
       lowercase    :				list[Stack]       		=							[]
       # sort into stacks
       for element in collection:
              lowercase    :				Union[str, Any]       		=							Stack([element]  )
              lowercase    :				Dict       		=							bisect_left(__snake_case     , __snake_case  )
              if i != len(__snake_case  ):
                     stacks[i].append(__snake_case  )
              else:
                     stacks.append(__snake_case  )

    # use a heap-based merge to merge stack efficiently
       lowercase    :				Dict       		=							merge(*(reversed(__snake_case  ) for stack in stacks)  )
       return collection


if __name__ == "__main__":
   _A			:       Optional[int]   		=       input("""Enter numbers separated by a comma:\n""").strip()
   _A			:       Optional[Any]   		=       [int(item) for item in user_input.split(""",""")]
   print(patience_sort(unsorted))


