code: 
  
  
  
  
  
  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)
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  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}""")
  
  
  
  
  
  