



'''simple docstring'''



from __future__ import annotations


def 							__UpperCAmelCase				(				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						Tuple:
				assert (
				    c % greatest_common_divisor(__lowerCamelCase   ,				__lowerCamelCase			) == 0
				)  # greatest_common_divisor(a,b) function implemented below
				(snake_case__)      :   Any      =    extended_gcd(__lowerCamelCase   ,				__lowerCamelCase			)  # extended_gcd(a,b) function implemented below
				snake_case__      :   Any      =    c / d
				return (r * x, r * y)


def 							__UpperCAmelCase				(				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int   ,				UpperCamelCase__				:int = 2			)		->						Union[str, Any]:
				(snake_case__)      :   Tuple      =    diophantine(__lowerCamelCase   ,				__lowerCamelCase   ,				__lowerCamelCase			)  # Initial value
				snake_case__      :   Union[str, Any]      =    greatest_common_divisor(__lowerCamelCase   ,				__lowerCamelCase			)
				snake_case__      :   Optional[int]      =    a // d
				snake_case__      :   Dict      =    b // d

				for i in range(__lowerCamelCase			):
								snake_case__      :   Any      =    xa + i * q
								snake_case__      :   int      =    ya - i * p
								print(__lowerCamelCase   ,				__lowerCamelCase			)


def 							__UpperCAmelCase				(				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						List[Any]:
				if a < b:
								snake_case__      :   List[Any]      =    b, a

				while a % b != 0:
								snake_case__      :   Optional[Any]      =    b, a % b

				return b


def 							__UpperCAmelCase				(				UpperCamelCase__				:int   ,				UpperCamelCase__				:int			)		->						int:
				assert a >= 0 and b >= 0

				if b == 0:
								snake_case__      :   Optional[int]      =    a, 1, 0
				else:
								(snake_case__)      :   List[str]      =    extended_gcd(__lowerCamelCase   ,				a % b			)
								snake_case__      :   int      =    q
								snake_case__      :   Optional[Any]      =    p - q * (a // b)

				assert a % d == 0 and b % d == 0
				assert d == a * x + b * y

				return (d, x, y)


if __name__ == "__main__":
				from doctest import testmod

				testmod(name="diophantine", verbose=True)
				testmod(name="diophantine_all_soln", verbose=True)
				testmod(name="extended_gcd", verbose=True)
				testmod(name="greatest_common_divisor", verbose=True)









"""simple docstring"""






def 	snake_case__  (						__lowerCamelCase							:       Union[str, Any]      ):
			"""simple docstring"""
			lowerCamelCase__						:						Dict						      =len(__lowerCamelCase      )
			for i in range(length - 1      ):
						lowerCamelCase__						:						Any						      =False
						for j in range(length - 1 - i      ):
									if collection[j] > collection[j + 1]:
												lowerCamelCase__						:						List[str]						      =True
												lowerCamelCase__      ,  lowerCamelCase__						:						List[str]						      =collection[j + 1], collection[j]
						if not swapped:
									break  # Stop iteration if the collection is sorted.
			return collection


if __name__ == "__main__":
		import doctest
		import time

		doctest.testmod()

		_lowercase					:					str 		=		input("Enter numbers separated by a comma:").strip()
		_lowercase					:					Dict 		=		[int(item) for item in user_input.split(",")]
		_lowercase					:					Optional[Any] 		=		time.process_time()
		print(*bubble_sort(unsorted), sep=",")
		print(f'Processing time: {(time.process_time() - start)%1E9 + 7}')




