"""simple docstring"""







import math
def   __UpperCAmelCase    (   UpperCAmelCase_   :    list      ,							UpperCAmelCase_   :    int = 0      ,							UpperCAmelCase_   :    int = 0  )							->      list:

	'''simple docstring'''





	__snake_case      :							Tuple						=			end or len(UpperCAmelCase_  )
	for i in range(UpperCAmelCase_      ,							UpperCAmelCase_  ):
		__snake_case      :							int						=			i
		__snake_case      :							List[Any]						=			array[i]
		while temp_index != start and temp_index_value < array[temp_index - 1]:
			__snake_case      :							List[str]						=			array[temp_index - 1]
			temp_index -= 1
		__snake_case      :							List[str]						=			temp_index_value
	return array
def   __UpperCAmelCase    (   UpperCAmelCase_   :    list      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int  )							->      None:  # Max Heap

	'''simple docstring'''





	__snake_case      :							Tuple						=			index
	__snake_case      :							Tuple						=			2 * index + 1  # Left Node
	__snake_case      :							Any						=			2 * index + 2  # Right Node

	if left_index < heap_size and array[largest] < array[left_index]:
		__snake_case      :							Optional[int]						=			left_index

	if right_index < heap_size and array[largest] < array[right_index]:
		__snake_case      :							Dict						=			right_index

	if largest != index:
		__snake_case		,    __snake_case      :							int						=			array[largest], array[index]
		heapify(UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
def   __UpperCAmelCase    (   UpperCAmelCase_   :    list  )							->      list:

	'''simple docstring'''





	__snake_case      :							Dict						=			len(UpperCAmelCase_  )

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

	for i in range(n - 1      ,							0      ,							-1  ):
		__snake_case		,    __snake_case      :							List[str]						=			array[0], array[i]
		heapify(UpperCAmelCase_      ,							0      ,							UpperCAmelCase_  )

	return array
def   __UpperCAmelCase    (   UpperCAmelCase_   :    list      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int  )							->      int:

	'''simple docstring'''





	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   __UpperCAmelCase    (   UpperCAmelCase_   :    list      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int  )							->      int:

	'''simple docstring'''





	__snake_case      :							List[str]						=			low
	__snake_case      :							Union[str, Any]						=			high
	while True:
		while array[i] < pivot:
			i += 1
		j -= 1
		while pivot < array[j]:
			j -= 1
		if i >= j:
			return i
		__snake_case		,    __snake_case      :							List[Any]						=			array[j], array[i]
		i += 1
def   __UpperCAmelCase    (   UpperCAmelCase_   :    list  )							->      list:

	'''simple docstring'''





	if len(UpperCAmelCase_  ) == 0:
		return array
	__snake_case      :							Any						=			2 * math.ceil(math.loga(len(UpperCAmelCase_  )  )  )
	__snake_case      :							Dict						=			16
	return intro_sort(UpperCAmelCase_      ,							0      ,							len(UpperCAmelCase_  )      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
def   __UpperCAmelCase    (   UpperCAmelCase_   :    list      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int      ,							UpperCAmelCase_   :    int  )							->      list:

	'''simple docstring'''





	while end - start > size_threshold:
		if max_depth == 0:
			return heap_sort(UpperCAmelCase_  )
		max_depth -= 1
		__snake_case      :							int						=			median_of_a(UpperCAmelCase_      ,							UpperCAmelCase_      ,							start + ((end - start) // 2) + 1      ,							end - 1  )
		__snake_case      :							Optional[int]						=			partition(UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
		intro_sort(UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )
		__snake_case      :							List[Any]						=			p
	return insertion_sort(UpperCAmelCase_      ,							UpperCAmelCase_      ,							UpperCAmelCase_  )


if __name__ == "__main__":
	import doctest

	doctest.testmod()

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






"""simple docstring"""







from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig


_a					:					Tuple=			{
    "albert-base-v1": "https://huggingface.co/albert-base-v1/resolve/main/config.json",
    "albert-large-v1": "https://huggingface.co/albert-large-v1/resolve/main/config.json",
    "albert-xlarge-v1": "https://huggingface.co/albert-xlarge-v1/resolve/main/config.json",
    "albert-xxlarge-v1": "https://huggingface.co/albert-xxlarge-v1/resolve/main/config.json",
    "albert-base-v2": "https://huggingface.co/albert-base-v2/resolve/main/config.json",
    "albert-large-v2": "https://huggingface.co/albert-large-v2/resolve/main/config.json",
    "albert-xlarge-v2": "https://huggingface.co/albert-xlarge-v2/resolve/main/config.json",
    "albert-xxlarge-v2": "https://huggingface.co/albert-xxlarge-v2/resolve/main/config.json",
}

class 		UpperCamelCase      (   lowercase						):
				UpperCAmelCase    :				str   =		"""albert"""



				def __init__(self    :				Union[str, Any]     ,  _A    :				int=3_00_00     ,  _A    :				Any=1_28     ,  _A    :				Tuple=40_96     ,  _A    :				int=12     ,  _A    :				Tuple=1     ,  _A    :				int=64     ,  _A    :				Optional[Any]=1_63_84     ,  _A    :				Optional[Any]=1     ,  _A    :				List[str]="gelu_new"     ,  _A    :				Any=0     ,  _A    :				Optional[Any]=0     ,  _A    :				List[Any]=5_12     ,  _A    :				List[Any]=2     ,  _A    :				Dict=0.02     ,  _A    :				Union[str, Any]=1E-12     ,  _A    :				Tuple=0.1     ,  _A    :				int="absolute"     ,  _A    :				List[Any]=0     ,  _A    :				str=2     ,  _A    :				int=3     ,  **_A    :				Tuple     ,  )   ->     Union[str, Any]:
					super().__init__(pad_token_id=_A     ,  bos_token_id=_A     ,  eos_token_id=_A     ,  **_A)

					__snake_case      :							str						=			vocab_size
					__snake_case      :							List[Any]						=			embedding_size
					__snake_case      :							Tuple						=			hidden_size
					__snake_case      :							Optional[Any]						=			num_hidden_layers
					__snake_case      :							List[str]						=			num_hidden_groups
					__snake_case      :							Dict						=			num_attention_heads
					__snake_case      :							Any						=			inner_group_num
					__snake_case      :							Union[str, Any]						=			hidden_act
					__snake_case      :							List[Any]						=			intermediate_size
					__snake_case      :							List[str]						=			hidden_dropout_prob
					__snake_case      :							int						=			attention_probs_dropout_prob
					__snake_case      :							Any						=			max_position_embeddings
					__snake_case      :							Optional[int]						=			type_vocab_size
					__snake_case      :							Optional[Any]						=			initializer_range
					__snake_case      :							List[Any]						=			layer_norm_eps
					__snake_case      :							Optional[Any]						=			classifier_dropout_prob
					__snake_case      :							List[str]						=			position_embedding_type







class 		UpperCamelCase      (   lowercase						):



				@property
				def  _lowercase					(self    :				Tuple)   ->     Mapping[str, Mapping[int, str]]:
					if self.task == "multiple-choice":
						__snake_case      :							int						=			{0: 'batch', 1: 'choice', 2: 'sequence'}
					else:
						__snake_case      :							Optional[Any]						=			{0: 'batch', 1: 'sequence'}
					return OrderedDict(
					    [
					        ('input_ids', dynamic_axis),
					        ('attention_mask', dynamic_axis),
					        ('token_type_ids', dynamic_axis),
					    ])





