


"""simple docstring"""


import math






def      a__ (				__lowercase   )	->	bool:

				if 1 < number < 4:
								# 2 and 3 are primes
								return True
				elif number < 2 or number % 2 == 0 or number % 3 == 0:
								# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
								return False

				# All primes number are in format of 6k +/- 1
				for i in range(5     ,			int(math.sqrt(__lowercase   ) + 1   )     ,			6   ):
								if number % i == 0 or number % (i + 2) == 0:
												return False
				return True






def      a__ (				__lowercase = 0.1   )	->	int:
				_A					  =			3
				_A					  =			3

				while primes / (2 * j - 1) >= ratio:
								for i in range(j * j + j + 1     ,			(j + 2) * (j + 2)     ,			j + 1   ):
												primes += is_prime(__lowercase   )
								j += 2
				return j


if __name__ == "__main__":
		import doctest

		doctest.testmod()



"""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))