





from __future__ import annotations

def     a						(      _lowercase   :     int ,						_lowercase   :     int ,						_lowercase   :     int       )     ->List[str]:
			assert n > 1 and a > 0 and greatest_common_divisor(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE       ) == 1
			(UpperCamelCase__)         =	extended_gcd(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE       )  # Implemented below
			UpperCamelCase__         =	(b * s) % n
			return x

def     a						(      _lowercase   :     int ,						_lowercase   :     int       )     ->int:
			(UpperCamelCase__)         =	extended_euclid(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE       )  # Implemented below
			if b < 0:
						UpperCamelCase__         =	(b % n + n) % n
			return b

def     a						(      _lowercase   :     int ,						_lowercase   :     int ,						_lowercase   :     int       )     ->str:
			UpperCamelCase__         =	invert_modulo(_SCREAMING_SNAKE_CASE ,						_SCREAMING_SNAKE_CASE       )
			UpperCamelCase__         =	(b * s) % n
			return x

def     a						(      _lowercase   :     int ,						_lowercase   :     int       )     ->List[str]:
			assert a >= 0 and b >= 0

			if b == 0:
						UpperCamelCase__         =	a, 1, 0
			else:
						(UpperCamelCase__)         =	extended_gcd(_SCREAMING_SNAKE_CASE ,						a % b       )
						UpperCamelCase__         =	q
						UpperCamelCase__         =	p - q * (a // b)

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

			return (d, x, y)

def     a						(      _lowercase   :     int ,						_lowercase   :     int       )     ->Any:
			if b == 0:
						return (1, 0)
			(UpperCamelCase__)         =	extended_euclid(_SCREAMING_SNAKE_CASE ,						a % b       )
			UpperCamelCase__         =	a // b
			return (y, x - k * y)

def     a						(      _lowercase   :     int ,						_lowercase   :     int       )     ->Optional[int]:
			if a < b:
						UpperCamelCase__         =	b, a

			while a % b != 0:
						UpperCamelCase__         =	b, a % b

			return b


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

				testmod(name="modular_division", verbose=True)
				testmod(name="modular_division2", verbose=True)
				testmod(name="invert_modulo", verbose=True)
				testmod(name="extended_gcd", verbose=True)
				testmod(name="extended_euclid", verbose=True)
				testmod(name="greatest_common_divisor", verbose=True)












def     a						(      _lowercase   :     Optional[int]       )     ->List[str]:
		UpperCamelCase__         =	len(_lowercase       )
		for i in range(length - 1       ):
				UpperCamelCase__         =	False
				for j in range(length - 1 - i       ):
						if collection[j] > collection[j + 1]:
								UpperCamelCase__         =	True
								UpperCamelCase__  ,			UpperCamelCase__         =	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()

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





