


"""simple docstring"""


import operator as op






def      a__ (				__lowercase   )	->	str:
				_A					  =			[]
				_A					  =			lambda __lowercase     ,			__lowercase   : int(x / y   )  # noqa: E731 integer division operation
				_A					  =			{
				    "^": op.pow,
				    "*": op.mul,
				    "/": div,
				    "+": op.add,
				    "-": op.sub,
				}  # operators & their respective operation

				# print table header
				print("Symbol".center(8   )     ,			"Action".center(12   )     ,			"Stack"     ,			sep=" | "   )
				print("-" * (30 + len(__lowercase   ))   )

				for x in post_fix:
								if x.isdigit():  # if x in digit
												stack.append(__lowercase   )  # append x to stack
												# output in tabular format
												print(x.rjust(8   )     ,			("push(" + x + ")").ljust(12   )     ,			",".join(__lowercase   )     ,			sep=" | "   )
								else:
												_A					  =			stack.pop()  # pop stack
												# output in tabular format
												print("".rjust(8   )     ,			("pop(" + b + ")").ljust(12   )     ,			",".join(__lowercase   )     ,			sep=" | "   )

												_A					  =			stack.pop()  # pop stack
												# output in tabular format
												print("".rjust(8   )     ,			("pop(" + a + ")").ljust(12   )     ,			",".join(__lowercase   )     ,			sep=" | "   )

												stack.append(
												    str(opr[x](int(__lowercase   )     ,			int(__lowercase   )   )   )   )  # evaluate the 2 values popped from stack & push result to stack
												# output in tabular format
												print(
												    x.rjust(8   )     ,			("push(" + a + x + b + ")").ljust(12   )     ,			",".join(__lowercase   )     ,			sep=" | "     ,			)

				return int(stack[0]   )


if __name__ == "__main__":
		a_       							=    input("\n\nEnter a Postfix Equation (space separated) = ").split(" ")
		print("\n\tResult = ", solve(Postfix))



"""simple docstring"""


def      a__ (				__lowercase     ,			__lowercase     ,			__lowercase     ,			__lowercase   )	->	str:
				# Return True if there is node that has not iterated.
				_A					  =			[False] * len(__lowercase   )
				_A					  =			[]
				queue.append(__lowercase   )
				_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(__lowercase   )
																_A					  =			True
																_A					  =			u

				return visited[t]






def      a__ (				__lowercase     ,			__lowercase     ,			__lowercase   )	->	int:
				# This array is filled by BFS and to store path
				_A					  =			[-1] * (len(__lowercase   ))
				_A					  =			0
				while bfs(__lowercase     ,			__lowercase     ,			__lowercase     ,			__lowercase   ):
								_A					  =			float("Inf"   )
								_A					  =			sink

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


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

a_							,     a_       							=    0, 5




print(ford_fulkerson(graph, source, sink))