def      __lowercase  (		lowerCamelCase      :  list						,						lowerCamelCase      :  int						,						lowerCamelCase      :  int			):
 if right <= left:
  return
 UpperCamelCase_      :		str				=      left
 UpperCamelCase_      :		Union[str, Any]				=      right
 UpperCamelCase_      :		str				=      sorting[left]
 while i <= b:
  if sorting[i] < pivot:
   UpperCamelCase_      :		Dict				=      sorting[i], sorting[a]
   a += 1
   i += 1
  elif sorting[i] > pivot:
   UpperCamelCase_      :		Optional[int]				=      sorting[i], sorting[b]
   b -= 1
  else:
   i += 1
 quick_sort_apartition(lowerCamelCase						,						lowerCamelCase						,						a - 1			)
 quick_sort_apartition(lowerCamelCase						,						b + 1						,						lowerCamelCase			)





def      __lowercase  (		lowerCamelCase      :  list						,						lowerCamelCase      :  int						,						lowerCamelCase      :  int			):
 if left < right:
  UpperCamelCase_      :		Any				=      lomuto_partition(lowerCamelCase						,						lowerCamelCase						,						lowerCamelCase			)
  quick_sort_lomuto_partition(lowerCamelCase						,						lowerCamelCase						,						pivot_index - 1			)
  quick_sort_lomuto_partition(lowerCamelCase						,						pivot_index + 1						,						lowerCamelCase			)





def      __lowercase  (		lowerCamelCase      :  list						,						lowerCamelCase      :  int						,						lowerCamelCase      :  int			):
 UpperCamelCase_      :		str				=      sorting[right]
 UpperCamelCase_      :		Any				=      left
 for i in range(lowerCamelCase						,						lowerCamelCase			):
  if sorting[i] < pivot:
   UpperCamelCase_      :		Tuple				=      sorting[i], sorting[store_index]
   store_index += 1
 UpperCamelCase_      :		int				=      sorting[store_index], sorting[right]
 return store_index





def      __lowercase  (		lowerCamelCase      :  list			):
 if len(lowerCamelCase			) <= 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 __future__ import annotations

from collections import deque
from queue import Queue
from timeit import timeit

a_					      = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E'],
}





def      __lowercase  (		lowerCamelCase      :  dict						,						lowerCamelCase      :  str			):
 UpperCamelCase_      :		Tuple				=      {start}
 UpperCamelCase_      :		Optional[Any]				=      [start]
 UpperCamelCase_      :		Queue				=      Queue()
 queue.put(lowerCamelCase			)
 while not queue.empty():
  UpperCamelCase_      :		Union[str, Any]				=      queue.get()
  for w in graph[v]:
   if w not in explored:
    explored.add(lowerCamelCase			)
    result.append(lowerCamelCase			)
    queue.put(lowerCamelCase			)
 return result





def      __lowercase  (		lowerCamelCase      :  dict						,						lowerCamelCase      :  str			):
 UpperCamelCase_      :		Dict				=      {start}
 UpperCamelCase_      :		Optional[int]				=      [start]
 UpperCamelCase_      :		Union[str, Any]				=      deque([start]			)
 while queue:
  UpperCamelCase_      :		Optional[int]				=      queue.popleft()
  for child in graph[v]:
   if child not in visited:
    visited.add(lowerCamelCase			)
    result.append(lowerCamelCase			)
    queue.append(lowerCamelCase			)
 return result





def      __lowercase  (		lowerCamelCase      :  str			):
 UpperCamelCase_      :		str				=      F"from __main__ import G, {name}"
 UpperCamelCase_      :		int				=      10000
 UpperCamelCase_      :		Optional[Any]				=      timeit(F"{name}(G, 'A')"						,						setup=lowerCamelCase						,						number=lowerCamelCase			)
 print(F"{name:<35} finished {number} runs in {res:.5f} seconds"			)


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   benchmark_function('breadth_first_search')
   benchmark_function('breadth_first_search_with_deque')
   # breadth_first_search                finished 10000 runs in 0.20999 seconds
   # breadth_first_search_with_deque     finished 10000 runs in 0.01421 seconds



