



from __future__ import annotations
def 	lowercase_							(A			:			int		, A			:			int		, A			:			int				):
       assert (
           c % greatest_common_divisor(A		, A				) == 0
       )  # greatest_common_divisor(a,b) function implemented below
       ((snake_case__)     ,    (snake_case__)     ,    (snake_case__))							:     Dict            =     extended_gcd(A		, A				)  # extended_gcd(a,b) function implemented below
       snake_case__							:     int            =     c / d
       return (r * x, r * y)
def 	lowercase_							(A			:			int		, A			:			int		, A			:			int		, A			:			int = 2				):
       ((snake_case__)     ,    (snake_case__))							:     Optional[int]            =     diophantine(A		, A		, A				)  # Initial value
       snake_case__							:     Dict            =     greatest_common_divisor(A		, A				)
       snake_case__							:     int            =     a // d
       snake_case__							:     Union[str, Any]            =     b // d

       for i in range(A				):
              snake_case__							:     Optional[Any]            =     xa + i * q
              snake_case__							:     Tuple            =     ya - i * p
              print(A		, A				)
def 	lowercase_							(A			:			int		, A			:			int				):
       if a < b:
              snake_case__     ,    snake_case__							:     Dict            =     b, a

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

       return b
def 	lowercase_							(A			:			int		, A			:			int				):
       assert a >= 0 and b >= 0

       if b == 0:
              snake_case__     ,    snake_case__     ,    snake_case__							:     List[Any]            =     a, 1, 0
       else:
              ((snake_case__)     ,    (snake_case__)     ,    (snake_case__))							:     Optional[Any]            =     extended_gcd(A		, a % b				)
              snake_case__							:     str            =     q
              snake_case__							:     Optional[int]            =     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)











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

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






