






def    a__    (	A		,					A		,					A       ):






   if right <= left:
      return
   lowercase__    :						List[Any]       =			left
   lowercase__    :						Optional[Any]       =			right
   lowercase__    :						str       =			sorting[left]
   while i <= b:
      if sorting[i] < pivot:
         lowercase__  ,       lowercase__    :						List[str]       =			sorting[i], sorting[a]
         a += 1
         i += 1
      elif sorting[i] > pivot:
         lowercase__  ,       lowercase__    :						Tuple       =			sorting[i], sorting[b]
         b -= 1
      else:
         i += 1
   quick_sort_apartition(_UpperCAmelCase		,					_UpperCAmelCase		,					a - 1       )
   quick_sort_apartition(_UpperCAmelCase		,					b + 1		,					_UpperCAmelCase       )
def    a__    (	A		,					A		,					A       ):






   if left < right:
      lowercase__    :						List[str]       =			lomuto_partition(_UpperCAmelCase		,					_UpperCAmelCase		,					_UpperCAmelCase       )
      quick_sort_lomuto_partition(_UpperCAmelCase		,					_UpperCAmelCase		,					pivot_index - 1       )
      quick_sort_lomuto_partition(_UpperCAmelCase		,					pivot_index + 1		,					_UpperCAmelCase       )
def    a__    (	A		,					A		,					A       ):
   lowercase__    :						Tuple       =			sorting[right]
   lowercase__    :						int       =			left
   for i in range(_UpperCAmelCase		,					_UpperCAmelCase       ):
      if sorting[i] < pivot:
         lowercase__  ,       lowercase__    :						Dict       =			sorting[i], sorting[store_index]
         store_index += 1
   lowercase__  ,       lowercase__    :						int       =			sorting[store_index], sorting[right]
   return store_index
def    a__    (	A       ):






   if len(_UpperCAmelCase       ) <= 1:
      return sorting
   return (
       three_way_radix_quicksort([i for i in sorting if i < sorting[0]]       )
       + [i for i in sorting if i == sorting[0]]
       + three_way_radix_quicksort([i for i in sorting if i > sorting[0]]       )
   )


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)

 a 			=							input('Enter numbers separated by a comma:\n').strip()
 a 			=							[int(item) for item in user_input.split(',')]
 quick_sort_apartition(unsorted, 0, len(unsorted) - 1)
 print(unsorted)







from collections.abc import Callable

__magic_name__       =     Callable[[float], float]  # type alias for a real -> real function





def 		__snake_case						(    _UpperCAmelCase       ,			_UpperCAmelCase       ,			_UpperCAmelCase       ,			):
					"""simple docstring"""






					lowercase						   =       float(_UpperCAmelCase				)
					while True:
										try:
															lowercase						   =       prev_guess - function(_UpperCAmelCase				) / derivative(_UpperCAmelCase				)
										except ZeroDivisionError:
															raise ZeroDivisionError('Could not find root'				) from None
										if abs(prev_guess - next_guess				) < 10**-5:
															return next_guess
										lowercase						   =       next_guess





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					return (x**3) - (2 * x) - 5





def 		__snake_case						(    _UpperCAmelCase				):
					"""simple docstring"""






					return 3 * (x**2) - 2


if __name__ == "__main__":
		print(newton(f, fa, 3))






