'''simple docstring'''




import copy
import random

from transformers import CLIPTokenizer




class     a__      (   snake_case_ ):






     def __init__( self		:		str  ,				*a		:		int  ,				**a		:		Any    ):





         """simple docstring"""



         super().__init__(*a  ,				**a    )
         __lowerCamelCase		=  {}






     def    SCREAMING_SNAKE_CASE__   ( self		:		List[Any]  ,				a		:		Optional[Any]  ,				*a		:		Union[str, Any]  ,				**a		:		Tuple    ):





         """simple docstring"""



         __lowerCamelCase		=  super().add_tokens(a  ,				*a  ,				**a    )
         if num_added_tokens == 0:
             raise ValueError(
                 f"""The tokenizer already contains the token {placeholder_token}. Please pass a different"""
                 ''' `placeholder_token` that is not already in the tokenizer.'''    )






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any  ,				a		:		List[str]  ,				*a		:		List[Any]  ,				a		:		List[str]=1  ,				**a		:		Tuple    ):





         """simple docstring"""



         __lowerCamelCase		=  []
         if num_vec_per_token == 1:
             self.try_adding_tokens(a  ,				*a  ,				**a    )
             output.append(a    )
         else:
             __lowerCamelCase		=  []
             for i in range(a    ):
                 __lowerCamelCase		=  placeholder_token + f"""_{i}"""
                 self.try_adding_tokens(a  ,				*a  ,				**a    )
                 output.append(a    )
        # handle cases where there is a new placeholder token that contains the current placeholder token but is larger
         for token in self.token_map:
             if token in placeholder_token:
                 raise ValueError(
                     f"""The tokenizer already has placeholder token {token} that can get confused with"""
                     f""" {placeholder_token}keep placeholder tokens independent"""    )
         __lowerCamelCase		=  output






     def    SCREAMING_SNAKE_CASE__   ( self		:		Any  ,				a		:		Optional[int]  ,				a		:		Optional[int]=False  ,				a		:		List[Any]=1.0    ):





         """simple docstring"""



         if isinstance(a  ,				a    ):
             __lowerCamelCase		=  []
             for i in range(len(a    )    ):
                 output.append(self.replace_placeholder_tokens_in_text(text[i]  ,				vector_shuffle=a    )    )
             return output
         for placeholder_token in self.token_map:
             if placeholder_token in text:
                 __lowerCamelCase		=  self.token_map[placeholder_token]
                 __lowerCamelCase		=  tokens[: 1 + int(len(a    ) * prop_tokens_to_load    )]
                 if vector_shuffle:
                     __lowerCamelCase		=  copy.copy(a    )
                     random.shuffle(a    )
                 __lowerCamelCase		=  text.replace(a  ,				''' '''.join(a    )    )
         return text






     def __call__( self		:		str  ,				a		:		List[Any]  ,				*a		:		Union[str, Any]  ,				a		:		Tuple=False  ,				a		:		Optional[Any]=1.0  ,				**a		:		str    ):





         """simple docstring"""



         return super().__call__(
             self.replace_placeholder_tokens_in_text(
                 a  ,				vector_shuffle=a  ,				prop_tokens_to_load=a    )  ,				*a  ,				**a  ,				)






     def    SCREAMING_SNAKE_CASE__   ( self		:		Optional[int]  ,				a		:		List[Any]  ,				*a		:		List[str]  ,				a		:		Optional[int]=False  ,				a		:		List[str]=1.0  ,				**a		:		Tuple    ):





         """simple docstring"""



         return super().encode(
             self.replace_placeholder_tokens_in_text(
                 a  ,				vector_shuffle=a  ,				prop_tokens_to_load=a    )  ,				*a  ,				**a  ,				)


import math





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





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):  # Max Heap
				lowerCamelCase_						=			index
				lowerCamelCase_						=			2 * index + 1  # Left Node
				lowerCamelCase_						=			2 * index + 2  # Right Node

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

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

				if largest != index:
								lowerCamelCase_	,    lowerCamelCase_						=			array[largest], array[index]
								heapify(lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    )





def 			lowerCamelCase_ (				lowerCamelCase__    ):
				lowerCamelCase_						=			len(lowerCamelCase__    )

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

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

				return array





def 			lowerCamelCase_ (				lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__	, lowerCamelCase__    ):
				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__    ):
				lowerCamelCase_						=			low
				lowerCamelCase_						=			high
				while True:
								while array[i] < pivot:
												i += 1
								j -= 1
								while pivot < array[j]:
												j -= 1
								if i >= j:
												return i
								lowerCamelCase_	,    lowerCamelCase_						=			array[j], array[i]
								i += 1





def 			lowerCamelCase_ (				lowerCamelCase__    ):
				if len(lowerCamelCase__    ) == 0:
								return array
				lowerCamelCase_						=			2 * math.ceil(math.loga(len(lowerCamelCase__    )    )    )
				lowerCamelCase_						=			1_6
				return intro_sort(lowerCamelCase__	, 0	, len(lowerCamelCase__    )	, lowerCamelCase__	, lowerCamelCase__    )





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


if __name__ == "__main__":
			import doctest

			doctest.testmod()

			__A				=input('''Enter numbers separated by a comma : ''').strip()
			__A				=[float(item) for item in user_input.split(''',''')]
			print(sort(unsorted))


