



"""simple docstring"""







def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Tuple     ,		lowerCamelCase_:							Optional[Any]     ,		lowerCamelCase_:							str     ,		lowerCamelCase_:							Optional[int] ):
						"""simple docstring"""






						snake_case   :			str						    = [False] * len(lowerCamelCase_ )
						snake_case   :			List[str]						    = []
						queue.append(lowerCamelCase_ )
						snake_case   :			List[Any]						    = True

						while queue:
												snake_case   :			List[Any]						    = queue.pop(0 )
												for ind in range(len(graph[u] ) ):
																		if visited[ind] is False and graph[u][ind] > 0:
																								queue.append(lowerCamelCase_ )
																								snake_case   :			List[Any]						    = True
																								snake_case   :			Dict						    = u

						return visited[t]

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							Any     ,		lowerCamelCase_:							int     ,		lowerCamelCase_:							Optional[int] ):
						"""simple docstring"""






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

												while s != source:
																		# Find the minimum value in select path
																		snake_case   :			int						    = min(lowerCamelCase_     ,		graph[parent[s]][s] )
																		snake_case   :			Tuple						    = parent[s]

												max_flow += path_flow
												snake_case   :			List[str]						    = sink

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


A		=						[
    [0, 1_6, 1_3, 0, 0, 0],
    [0, 0, 1_0, 1_2, 0, 0],
    [0, 4, 0, 0, 1_4, 0],
    [0, 0, 9, 0, 0, 2_0],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

A	,	A		=						0, 5
print(ford_fulkerson(graph, source, sink))








"""simple docstring"""







import requests

def  __SCREAMING_SNAKE_CASE		(			lowerCamelCase_:							str     ,		lowerCamelCase_:							str ):
						"""simple docstring"""






						snake_case   :			List[str]						    = {"Content-Type": "application/json"}
						snake_case   :			int						    = requests.post(lowerCamelCase_     ,		json={"text": message_body}     ,		headers=lowerCamelCase_ )
						if response.status_code != 2_0_0:
												snake_case   :			str						    = (
												    "Request to slack returned an error "
												    f'''{response.status_code}, the response is:\n{response.text}'''
												)
												raise ValueError(lowerCamelCase_ )


if __name__ == "__main__":
			# Set the slack url to the one provided by Slack when you create the webhook at
			# https://my.slack.com/services/new/incoming-webhook/
			send_slack_message('<YOUR MESSAGE BODY>', '<SLACK CHANNEL URL>')



