


"""simple docstring"""


import math



def   snake_case						(				_a:     list		,   _a:     int = 0		,   _a:     int = 0							)->		list:
      '''simple docstring'''


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



def   snake_case						(				_a:     list		,   _a:     int		,   _a:     int							)->		None:  # Max Heap
      '''simple docstring'''


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

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

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

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



def   snake_case						(				_a:     list							)->		list:
      '''simple docstring'''


      lowerCamelCase__           =		len(_a							)

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

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

      return array



def   snake_case						(				_a:     list		,   _a:     int		,   _a:     int		,   _a:     int							)->		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   snake_case						(				_a:     list		,   _a:     int		,   _a:     int		,   _a:     int							)->		int:
      '''simple docstring'''


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



def   snake_case						(				_a:     list							)->		list:
      '''simple docstring'''


      if len(_a							) == 0:
            return array
      lowerCamelCase__           =		2 * math.ceil(math.loga(len(_a							)							)							)
      lowerCamelCase__           =		16
      return intro_sort(_a		,   0		,   len(_a							)		,   _a		,   _a							)



def   snake_case						(				_a:     list		,   _a:     int		,   _a:     int		,   _a:     int		,   _a:     int							)->		list:
      '''simple docstring'''


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


if __name__ == "__main__":
   import doctest

   doctest.testmod()

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







"""simple docstring"""


def   snake_case						(				_a:     List[Any]		,   _a:     Any		,   _a:     str		,   _a:     List[Any]							)->		List[Any]:
      '''simple docstring'''


      lowerCamelCase__           =		[False] * len(_a							)
      lowerCamelCase__           =		[]
      queue.append(_a							)
      lowerCamelCase__           =		True

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

      return visited[t]



def   snake_case						(				_a:     List[Any]		,   _a:     str		,   _a:     List[str]							)->		Optional[int]:
      '''simple docstring'''


      lowerCamelCase__           =		[-1] * (len(_a							))
      lowerCamelCase__           =		0
      while bfs(_a		,   _a		,   _a		,   _a							):
            lowerCamelCase__           =		float('Inf'							)
            lowerCamelCase__           =		sink

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

            max_flow += path_flow
            lowerCamelCase__           =		sink

            while v != source:
                  lowerCamelCase__           =		parent[v]
                  graph[u][v] -= path_flow
                  graph[v][u] += path_flow
                  lowerCamelCase__           =		parent[v]
      return max_flow


_snake_case          =							[
    [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],
]

_snake_case      ,					_snake_case          =							0, 5






print(ford_fulkerson(graph, source, sink))



