

'''simple docstring'''





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 				_lowerCAmelCase			(   __magic_name__						:     List[str]   , __magic_name__						:     Tuple   , __magic_name__						:     List[Any]   , __magic_name__						:     Optional[int]						)				->  Optional[Any]:
						# Return True if there is node that has not iterated.
						lowercase :							Dict    		=[False] * len(__magic_name__						)
						lowercase :							Optional[int]    		=[s]
						lowercase :							Any    		=True

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

						return visited[t]






def 				_lowerCAmelCase			(   __magic_name__						:     List[str]   , __magic_name__						:     str   , __magic_name__						:     List[str]						)				->  Union[str, Any]:
						lowercase :							Tuple    		=[-1] * (len(__magic_name__						))
						lowercase :							Tuple    		=0
						lowercase :							Any    		=[]
						lowercase :							int    		=[i[:] for i in graph]  # Record original cut, copy.
						while bfs(__magic_name__   , __magic_name__   , __magic_name__   , __magic_name__						):
												lowercase :							List[str]    		=float('''Inf'''						)
												lowercase :							List[str]    		=sink

												while s != source:
																		# Find the minimum value in select path
																		lowercase :							Union[str, Any]    		=min(__magic_name__   , graph[parent[s]][s]						)
																		lowercase :							Dict    		=parent[s]

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

												while v != source:
																		lowercase :							str    		=parent[v]
																		graph[u][v] -= path_flow
																		graph[v][u] += path_flow
																		lowercase :							List[Any]    		=parent[v]

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








'''simple docstring'''





import datasets


UpperCamelCase_    						=       """\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
"""

UpperCamelCase_    						=       """\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

UpperCamelCase_    						=       """
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""






def 				_lowerCAmelCase			(   __magic_name__						:     Dict   , __magic_name__						:     Union[str, Any]						)				->  Union[str, Any]:
						return (preds == labels).mean()







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,							_KWARGS_DESCRIPTION      )
class 		__SCREAMING_SNAKE_CASE							(			datasets.Metric      ):







				def  lowerCamelCase_	(       self     :		str   ):
										'''simple docstring'''
										return datasets.MetricInfo(
										    description=_DESCRIPTION		,					citation=_CITATION		,					inputs_description=_KWARGS_DESCRIPTION		,					features=datasets.Features(
										        {
										            '''predictions''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''   ),
										            '''references''': datasets.Value('''int64''' if self.config_name != '''sts-b''' else '''float32'''   ),
										        }   )		,					codebase_urls=[]		,					reference_urls=[]		,					format='''numpy'''		,					)







				def  lowerCamelCase_	(       self     :		int		,					UpperCAmelCase__     :		Dict		,					UpperCAmelCase__     :		Optional[Any]   ):
										'''simple docstring'''
										return {"accuracy": simple_accuracy(UpperCAmelCase__		,					UpperCAmelCase__   )}





