





'''simple docstring'''

def 						UpperCamelCase    (							_lowerCamelCase : Tuple	):
    stooge(_lowerCamelCase						,	0						,	len(_lowerCamelCase	) - 1	)
    return arr





def 						UpperCamelCase    (							_lowerCamelCase : Tuple						,	_lowerCamelCase : Dict						,	_lowerCamelCase : Optional[int]	):
    if i >= h:
        return

    # If first element is smaller than the last then swap them
    if arr[i] > arr[h]:
        A__,     A__    =      arr[h], arr[i]

    # If there are more than 2 elements in the array
    if h - i + 1 > 2:
        A__    =      (int)((h - i + 1) / 3	)

        # Recursively sort first 2/3 elements
        stooge(_lowerCamelCase						,	_lowerCamelCase						,	(h - t)	)

        # Recursively sort last 2/3 elements
        stooge(_lowerCamelCase						,	i + t						,	(_lowerCamelCase)	)

        # Recursively sort first 2/3 elements
        stooge(_lowerCamelCase						,	_lowerCamelCase						,	(h - t)	)


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










'''simple docstring'''

def 						UpperCamelCase    (							_lowerCamelCase : List[Any]						,	_lowerCamelCase : List[str]						,	_lowerCamelCase : List[str]						,	_lowerCamelCase : Tuple	):
    # Return True if there is node that has not iterated.
    A__    =      [False] * len(_lowerCamelCase	)
    A__    =      []
    queue.append(_lowerCamelCase	)
    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(_lowerCamelCase	)
                A__    =      True
                A__    =      u

    return visited[t]





def 						UpperCamelCase    (							_lowerCamelCase : Optional[Any]						,	_lowerCamelCase : Optional[Any]						,	_lowerCamelCase : Optional[int]	):
    # This array is filled by BFS and to store path
    A__    =      [-1] * (len(_lowerCamelCase	))
    A__    =      0
    while bfs(_lowerCamelCase						,	_lowerCamelCase						,	_lowerCamelCase						,	_lowerCamelCase	):
        A__    =      float("Inf"	)
        A__    =      sink

        while s != source:
            # Find the minimum value in select path
            A__    =      min(_lowerCamelCase						,	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]
    return max_flow


__lowerCAmelCase							:     Any		     =[
    [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],
]

__lowerCAmelCase     ,					__lowerCAmelCase							:     int		     =0, 5



print(ford_fulkerson(graph, source, sink))



