





def  __UpperCamelCase   (     a,  a)			->Dict:
					lowerCamelCase__      =							[]
					lowerCamelCase__      =							len(__lowerCamelCase)
					for i in range(__lowerCamelCase):
										lowerCamelCase__      =							[]
										for j in range(__lowerCamelCase):
															lowerCamelCase__      =							0
															for k in range(__lowerCamelCase):
																				lowerCamelCase__      =							val + matrix_a[i][k] * matrix_b[k][j]
															list_a.append(__lowerCamelCase)
										matrix_c.append(__lowerCamelCase)
					return matrix_c





def  __UpperCamelCase   (     a)			->int:
					return [[int(row == column) for column in range(__lowerCamelCase)] for row in range(__lowerCamelCase)]





def  __UpperCamelCase   (     a)			->List[Any]:



					if n <= 1:
										return n
					lowerCamelCase__      =							identity(2)
					lowerCamelCase__      =							[[1, 1], [1, 0]]
					lowerCamelCase__      =							n - 1
					while n > 0:
										if n % 2 == 1:
															lowerCamelCase__      =							multiply(__lowerCamelCase,  __lowerCamelCase)
										lowerCamelCase__      =							multiply(__lowerCamelCase,  __lowerCamelCase)
										lowerCamelCase__      =							int(n / 2)
					return res_matrix[0][0]





def  __UpperCamelCase   (     a)			->Dict:



					if n <= 1:
										return n
					lowerCamelCase__      =							0
					lowerCamelCase__      =							1
					for _ in range(2,  n + 1):
										lowerCamelCase__     ,		lowerCamelCase__      =							fiba, fiba + fiba
					return fiba





def  __UpperCamelCase   (     )			->str:



					for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
										lowerCamelCase__      =							int("".join(c for c in ordinal if c in "0123456789"))  # 1000th --> 1000
										print(
										    f"{ordinal} fibonacci number using matrix exponentiation is "
										    f"{nth_fibonacci_matrix(__lowerCamelCase)} and using bruteforce is "
										    f"{nth_fibonacci_bruteforce(__lowerCamelCase)}\n")
					# from timeit import timeit
					# print(timeit("nth_fibonacci_matrix(1000000)",
					#              "from main import nth_fibonacci_matrix", number=5))
					# print(timeit("nth_fibonacci_bruteforce(1000000)",
					#              "from main import nth_fibonacci_bruteforce", number=5))
					# 2.3342058970001744
					# 57.256506615000035


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()





from __future__ import annotations

from random import randrange




def SCREAMING_SNAKE_CASE_  (				__lowerCamelCase:		list  ):







	'''simple docstring'''



	if len(__lowerCamelCase  ) < 2:
		return collection
	lowercase_			 = randrange(len(__lowerCamelCase  )  )  # Use random element as pivot
	lowercase_			 = collection[pivot_index]
	lowercase_			 = []  # All elements greater than pivot
	lowercase_			 = []  # All elements less than or equal to pivot

	for element in collection[:pivot_index]:
		(greater if element > pivot else lesser).append(__lowerCamelCase  )

	for element in collection[pivot_index + 1 :]:
		(greater if element > pivot else lesser).append(__lowerCamelCase  )

	return [*quick_sort(__lowerCamelCase  ), pivot, *quick_sort(__lowerCamelCase  )]


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE__       			=				input("""Enter numbers separated by a comma:\n""").strip()
							SCREAMING_SNAKE_CASE__       			=				[int(item) for item in user_input.split(""",""")]
							print(quick_sort(unsorted))

