
from __future__ import annotations

import sys




def 						A_			(				snake_case				: int			,   snake_case				: int			)   ->     tuple[int, int]:



						'''simple docstring'''

						if abs(snake_case			) == 1:
												return a, 0
						elif abs(snake_case			) == 1:
												return 0, b

						__UpperCamelCase	,				__UpperCamelCase  	=      a, b
						__UpperCamelCase	,				__UpperCamelCase  	=      1, 0
						__UpperCamelCase	,				__UpperCamelCase  	=      0, 1

						while remainder != 0:
												__UpperCamelCase  	=      old_remainder // remainder
												__UpperCamelCase	,				__UpperCamelCase  	=      remainder, old_remainder - quotient * remainder
												__UpperCamelCase	,				__UpperCamelCase  	=      coeff_a, old_coeff_a - quotient * coeff_a
												__UpperCamelCase	,				__UpperCamelCase  	=      coeff_b, old_coeff_b - quotient * coeff_b

						# sign correction for negative numbers
						if a < 0:
												__UpperCamelCase  	=      -old_coeff_a
						if b < 0:
												__UpperCamelCase  	=      -old_coeff_b

						return old_coeff_a, old_coeff_b




def 						A_			(				)   ->     str:



						'''simple docstring'''

						if len(sys.argv			) < 3:
												print('''2 integer arguments required'''			)
												return 1
						__UpperCamelCase  	=      int(sys.argv[1]			)
						__UpperCamelCase  	=      int(sys.argv[2]			)
						print(extended_euclidean_algorithm(snake_case			,   snake_case			)			)
						return 0


if __name__ == "__main__":
				raise SystemExit(main())









'''simple docstring'''



def 							__UpperCAmelCase				(				UpperCamelCase__				:int			)		->						Any:
				snake_case__      :   Dict      =    len(UpperCamelCase__			)
				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)
																snake_case__      :   int      =    lst[j + 1]
																snake_case__      :   Tuple      =    lst[j]
																snake_case__      :   Tuple      =    temp
												if (
												    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
												):  # applying bubble sort algorithm from right to left (or backwards)
																snake_case__      :   Optional[Any]      =    lst[no_of_elements - 1 - j]
																snake_case__      :   Tuple      =    lst[no_of_elements - 2 - j]
																snake_case__      :   Any      =    temp
				return lst


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




