

import math
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int = 0			,a__    :   int = 0       )					->				list:
	__A :			Optional[int]		    =			end or len(a__       )
	for i in range(a__			,a__       ):
		__A :			List[Any]		    =			i
		__A :			Optional[int]		    =			array[i]
		while temp_index != start and temp_index_value < array[temp_index - 1]:
			__A :			Union[str, Any]		    =			array[temp_index - 1]
			temp_index -= 1
		__A :			List[Any]		    =			temp_index_value
	return array
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int       )					->				None:  # Max Heap
	__A :			Optional[int]		    =			index
	__A :			List[Any]		    =			2 * index + 1  # Left Node
	__A :			Optional[Any]		    =			2 * index + 2  # Right Node

	if left_index < heap_size and array[largest] < array[left_index]:
		__A :			str		    =			left_index

	if right_index < heap_size and array[largest] < array[right_index]:
		__A :			Any		    =			right_index

	if largest != index:
		__A    ,				__A :			Optional[Any]		    =			array[largest], array[index]
		heapify(a__			,a__			,a__       )
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list       )					->				list:
	__A :			Tuple		    =			len(a__       )

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

	for i in range(n - 1			,0			,-1       ):
		__A    ,				__A :			Any		    =			array[0], array[i]
		heapify(a__			,0			,a__       )

	return array
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int			,a__    :   int       )					->				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 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int			,a__    :   int       )					->				int:
	__A :			Tuple		    =			low
	__A :			str		    =			high
	while True:
		while array[i] < pivot:
			i += 1
		j -= 1
		while pivot < array[j]:
			j -= 1
		if i >= j:
			return i
		__A    ,				__A :			int		    =			array[j], array[i]
		i += 1
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list       )					->				list:
	if len(a__       ) == 0:
		return array
	__A :			int		    =			2 * math.ceil(math.loga(len(a__       )       )       )
	__A :			int		    =			16
	return intro_sort(a__			,0			,len(a__       )			,a__			,a__       )
def 							__SCREAMING_SNAKE_CASE     (   a__    :   list			,a__    :   int			,a__    :   int			,a__    :   int			,a__    :   int       )					->				list:
	while end - start > size_threshold:
		if max_depth == 0:
			return heap_sort(a__       )
		max_depth -= 1
		__A :			Union[str, Any]		    =			median_of_a(a__			,a__			,start + ((end - start) // 2) + 1			,end - 1       )
		__A :			List[Any]		    =			partition(a__			,a__			,a__			,a__       )
		intro_sort(a__			,a__			,a__			,a__			,a__       )
		__A :			Optional[int]		    =			p
	return insertion_sort(a__			,a__			,a__       )


if __name__ == "__main__":
			import doctest

			doctest.testmod()

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













import math
from collections.abc import Iterator
from itertools import takewhile

def   __lowercase       (			snake_case			):







				"""simple docstring"""






				if 1 < number < 4:
								# 2 and 3 are primes
								return True
				elif number < 2 or number % 2 == 0 or number % 3 == 0:
								# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
								return False

				# All primes number are in format of 6k +/- 1
				for i in range(5,	int(math.sqrt(snake_case			) + 1			),	6			):
								if number % i == 0 or number % (i + 2) == 0:
												return False
				return True

def   __lowercase       (			):







				"""simple docstring"""






				__magic_name__		:str   =   2
				while True:
								if is_prime(snake_case			):
												yield num
								num += 1

def   __lowercase       (			snake_case = 2_0_0_0_0_0_0			):







				"""simple docstring"""






				return sum(takewhile(lambda snake_case			: x < n,	prime_generator()			)			)


if __name__ == "__main__":
					print(f"{solution() = }")






