

"""simple docstring"""


import math



def   _A					(	_a	:						list     ,   _a	:						int = 0     ,   _a	:						int = 0				):



      """simple docstring"""






      A				  =		end or len(_a				)
      for i in range(_a     ,   _a				):
            A				  =		i
            A				  =		array[i]
            while temp_index != start and temp_index_value < array[temp_index - 1]:
                  A				  =		array[temp_index - 1]
                  temp_index -= 1
            A				  =		temp_index_value
      return array



def   _A					(	_a	:						list     ,   _a	:						int     ,   _a	:						int				):  # Max Heap



      """simple docstring"""






      A				  =		index
      A				  =		2 * index + 1  # Left Node
      A				  =		2 * index + 2  # Right Node

      if left_index < heap_size and array[largest] < array[left_index]:
            A				  =		left_index

      if right_index < heap_size and array[largest] < array[right_index]:
            A				  =		right_index

      if largest != index:
            A  ,			A				  =		array[largest], array[index]
            heapify(_a     ,   _a     ,   _a				)



def   _A					(	_a	:						list				):



      """simple docstring"""






      A				  =		len(_a				)

      for i in range(n // 2     ,   -1     ,   -1				):
            heapify(_a     ,   _a     ,   _a				)

      for i in range(n - 1     ,   0     ,   -1				):
            A  ,			A				  =		array[0], array[i]
            heapify(_a     ,   0     ,   _a				)

      return array



def   _A					(	_a	:						list     ,   _a	:						int     ,   _a	:						int     ,   _a	:						int				):



      """simple docstring"""






      if (array[first_index] > array[middle_index]) != (
          array[first_index] > array[last_index]
      ):
            return array[first_index]
      elif (array[middle_index] > array[first_index]) != (
          array[middle_index] > array[last_index]
      ):
            return array[middle_index]
      else:
            return array[last_index]



def   _A					(	_a	:						list     ,   _a	:						int     ,   _a	:						int     ,   _a	:						int				):



      """simple docstring"""






      A				  =		low
      A				  =		high
      while True:
            while array[i] < pivot:
                  i += 1
            j -= 1
            while pivot < array[j]:
                  j -= 1
            if i >= j:
                  return i
            A  ,			A				  =		array[j], array[i]
            i += 1



def   _A					(	_a	:						list				):



      """simple docstring"""






      if len(_a				) == 0:
            return array
      A				  =		2 * math.ceil(math.loga(len(_a				)				)				)
      A				  =		1_6
      return intro_sort(_a     ,   0     ,   len(_a				)     ,   _a     ,   _a				)



def   _A					(	_a	:						list     ,   _a	:						int     ,   _a	:						int     ,   _a	:						int     ,   _a	:						int				):



      """simple docstring"""






      while end - start > size_threshold:
            if max_depth == 0:
                  return heap_sort(_a				)
            max_depth -= 1
            A				  =		median_of_a(_a     ,   _a     ,   start + ((end - start) // 2) + 1     ,   end - 1				)
            A				  =		partition(_a     ,   _a     ,   _a     ,   _a				)
            intro_sort(_a     ,   _a     ,   _a     ,   _a     ,   _a				)
            A				  =		p
      return insertion_sort(_a     ,   _a     ,   _a				)


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  UpperCAmelCase													=input("Enter numbers separated by a comma : ").strip()
  UpperCAmelCase													=[float(item) for item in user_input.split(",")]
  print(sort(unsorted))







"""simple docstring"""


UpperCAmelCase													=[
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]



def   _A					(	_a	:						Dict     ,   _a	:						int     ,   _a	:						Dict     ,   _a	:						List[Any]				):



      """simple docstring"""






      A				  =		[False] * len(_a				)
      A				  =		[s]
      A				  =		True

      while queue:
            A				  =		queue.pop(0				)
            for ind in range(len(graph[u]				)				):
                  if visited[ind] is False and graph[u][ind] > 0:
                        queue.append(_a				)
                        A				  =		True
                        A				  =		u

      return visited[t]



def   _A					(	_a	:						str     ,   _a	:						Optional[Any]     ,   _a	:						Optional[int]				):



      """simple docstring"""






      A				  =		[-1] * (len(_a				))
      A				  =		0
      A				  =		[]
      A				  =		[i[:] for i in graph]  # Record original cut, copy.
      while bfs(_a     ,   _a     ,   _a     ,   _a				):
            A				  =		float("""Inf"""				)
            A				  =		sink

            while s != source:
                  # Find the minimum value in select path
                  A				  =		min(_a     ,   graph[parent[s]][s]				)
                  A				  =		parent[s]

            max_flow += path_flow
            A				  =		sink

            while v != source:
                  A				  =		parent[v]
                  graph[u][v] -= path_flow
                  graph[v][u] += path_flow
                  A				  =		parent[v]

      for i in range(len(_a				)				):
            for j in range(len(graph[0]				)				):
                  if graph[i][j] == 0 and temp[i][j] > 0:
                        res.append((i, j)				)

      return res


if __name__ == "__main__":
  print(mincut(test_graph, source=0, sink=5))




