




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   (		SCREAMING_SNAKE_CASE_							:       int   ,   SCREAMING_SNAKE_CASE_							:       Optional[Any]   ,   SCREAMING_SNAKE_CASE_							:       int   ,   SCREAMING_SNAKE_CASE_							:       Dict  ):
					# Return True if there is node that has not iterated.
					__lowerCAmelCase            = [False] * len(SCREAMING_SNAKE_CASE_  )
					__lowerCAmelCase            = [s]
					__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(SCREAMING_SNAKE_CASE_  )
																				__lowerCAmelCase            = True
																				__lowerCAmelCase            = u

					return visited[t]







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

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

					for i in range(len(SCREAMING_SNAKE_CASE_  )  ):
										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))










def 			_a   (		SCREAMING_SNAKE_CASE_							:       list[int]  ):
					__lowerCAmelCase            = len(SCREAMING_SNAKE_CASE_  )
					for i in range(SCREAMING_SNAKE_CASE_  ):
										for j in range(i + 1   ,   SCREAMING_SNAKE_CASE_  ):
															if numbers[j] < numbers[i]:
																				__lowerCAmelCase     ,							__lowerCAmelCase            = numbers[j], numbers[i]
					return numbers


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




