


def 				UpperCamelCase_	(					__snake_case      :    Union[str, Any]  )->   Tuple:




						'''simple docstring'''
						__magic_name__					=      len(__snake_case  )
						for _ in range(
						    0						,      int(((no_of_elements - 1) / 2) + 1  )  ):  # we don't need to traverse to end of list as
												for j in range(0						,      no_of_elements - 1  ):
																		if (
																		    lst[j + 1] < lst[j]
																		):  # applying bubble sort algorithm from left to right (or forwards)
																								__magic_name__					=      lst[j + 1]
																								__magic_name__					=      lst[j]
																								__magic_name__					=      temp
																		if (
																		    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
																		):  # applying bubble sort algorithm from right to left (or backwards)
																								__magic_name__					=      lst[no_of_elements - 1 - j]
																								__magic_name__					=      lst[no_of_elements - 2 - j]
																								__magic_name__					=      temp
						return lst


if __name__ == "__main__":
					print('''enter the list to be sorted''')
					UpperCamelCase			:					Any         =							[int(x) for x in input().split()]  # inputing elements of the list in one line
					UpperCamelCase			:					Union[str, Any]         =							double_sort(lst)
					print('''the sorted list is''')
					print(sorted_lst)





from itertools import count
from math import asin, pi, sqrt
def 				UpperCamelCase_	(					__snake_case      :    float  )->   float:




						'''simple docstring'''
						return (
						    (1 - 2 * point) * sqrt(point - point**2  ) + 2 * point + asin(sqrt(1 - point  )  )
						) / 4
def 				UpperCamelCase_	(					__snake_case      :    int  )->   float:




						'''simple docstring'''
						__magic_name__					=      (circles_number + 1 - sqrt(2 * circles_number  )) / (
						    2 * (circles_number**2 + 1)
						)
						__magic_name__					=      circles_number * intersection_y

						__magic_name__					=      intersection_x * intersection_y / 2
						__magic_name__					=      circle_bottom_arc_integral(
						    1 / 2  ) - circle_bottom_arc_integral(__snake_case  )

						return triangle_area + concave_region_area
def 				UpperCamelCase_	(					__snake_case      :    float = 1 / 10_00  )->   int:




						'''simple docstring'''
						__magic_name__					=      (1 - pi / 4) / 4

						for n in count(1  ):
												if concave_triangle_area(__snake_case  ) / l_section_area < fraction:
																		return n

						return -1


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

