
def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     List[Any]		,    _lowerCamelCase					:     Any		,    _lowerCamelCase					:     List[str]		,    _lowerCamelCase					:     Dict)   ->       Dict:






							'''simple docstring'''





							__UpperCamelCase      :  List[str]       =   [False] * len(_lowerCamelCase)
							__UpperCamelCase      :  Optional[Any]       =   []
							queue.append(_lowerCamelCase)
							__UpperCamelCase      :  str       =   True

							while queue:
														__UpperCamelCase      :  Optional[int]       =   queue.pop(0)
														for ind in range(len(graph[u])):
																					if visited[ind] is False and graph[u][ind] > 0:
																												queue.append(_lowerCamelCase)
																												__UpperCamelCase      :  Tuple       =   True
																												__UpperCamelCase      :  str       =   u

							return visited[t]




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     List[str]		,    _lowerCamelCase					:     Union[str, Any]		,    _lowerCamelCase					:     Optional[int])   ->       Union[str, Any]:






							'''simple docstring'''





							__UpperCamelCase      :  Optional[int]       =   [-1] * (len(_lowerCamelCase))
							__UpperCamelCase      :  List[Any]       =   0
							while bfs(_lowerCamelCase		,    _lowerCamelCase		,    _lowerCamelCase		,    _lowerCamelCase):
														__UpperCamelCase      :  Optional[Any]       =   float("Inf")
														__UpperCamelCase      :  Union[str, Any]       =   sink

														while s != source:
																					# Find the minimum value in select path
																					__UpperCamelCase      :  List[str]       =   min(_lowerCamelCase		,    graph[parent[s]][s])
																					__UpperCamelCase      :  Optional[int]       =   parent[s]

														max_flow += path_flow
														__UpperCamelCase      :  Optional[int]       =   sink

														while v != source:
																					__UpperCamelCase      :  Union[str, Any]       =   parent[v]
																					graph[u][v] -= path_flow
																					graph[v][u] += path_flow
																					__UpperCamelCase      :  Optional[int]       =   parent[v]
							return max_flow


lowercase    :   List[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],
]

lowercase				,     lowercase    :   Dict						=			0, 5




print(ford_fulkerson(graph, source, sink))

import math




def       _SCREAMING_SNAKE_CASE   (						_lowerCamelCase					:     int)   ->       str:






							'''simple docstring'''





							__UpperCamelCase      :  Union[str, Any]       =   0
							__UpperCamelCase      :  int       =   0
							while num > 0:
														__UpperCamelCase      :  List[Any]       =   num % 8
														__UpperCamelCase      :  Tuple       =   octal + (remainder * math.floor(math.pow(10		,    _lowerCamelCase)))
														counter += 1
														__UpperCamelCase      :  Optional[Any]       =   math.floor(num / 8)  # basically /= 8 without remainder if any
														# This formatting removes trailing '.0' from `octal`.
							return F'0o{int(_lowerCamelCase)}'




def       _SCREAMING_SNAKE_CASE   (						)   ->       None:






							'''simple docstring'''





							print("\n2 in octal is:")
							print(decimal_to_octal(2))  # = 2
							print("\n8 in octal is:")
							print(decimal_to_octal(8))  # = 10
							print("\n65 in octal is:")
							print(decimal_to_octal(65))  # = 101
							print("\n216 in octal is:")
							print(decimal_to_octal(216))  # = 330
							print("\n512 in octal is:")
							print(decimal_to_octal(512))  # = 1000
							print("\n")


if __name__ == "__main__":
		main()