"""simple docstring"""





__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],
]


def    lowercase_   (   _lowerCamelCase:	str						,   _lowerCamelCase:	str						,   _lowerCamelCase:	Tuple						,   _lowerCamelCase:	List[Any]      ) ->      Optional[Any]:



							'''simple docstring'''

							__lowerCamelCase					:		Tuple		   =     [False] * len(_lowerCamelCase      )
							__lowerCamelCase					:		Optional[int]		   =     [s]
							__lowerCamelCase					:		Dict		   =     True

							while queue:
														__lowerCamelCase					:		Union[str, Any]		   =     queue.pop(0      )
														for ind in range(len(graph[u]      )      ):
																					if visited[ind] is False and graph[u][ind] > 0:
																												queue.append(_lowerCamelCase      )
																												__lowerCamelCase					:		Any		   =     True
																												__lowerCamelCase					:		str		   =     u

							return visited[t]


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	List[str]						,   _lowerCamelCase:	int      ) ->      Dict:



							'''simple docstring'''

							__lowerCamelCase					:		Dict		   =     [-1] * (len(_lowerCamelCase      ))
							__lowerCamelCase					:		Union[str, Any]		   =     0
							__lowerCamelCase					:		Optional[Any]		   =     []
							__lowerCamelCase					:		int		   =     [i[:] for i in graph]  # Record original cut, copy.
							while bfs(_lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase      ):
														__lowerCamelCase					:		Union[str, Any]		   =     float("Inf"      )
														__lowerCamelCase					:		Any		   =     sink

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

														max_flow += path_flow
														__lowerCamelCase					:		Union[str, Any]		   =     sink

														while v != source:
																					__lowerCamelCase					:		Optional[int]		   =     parent[v]
																					graph[u][v] -= path_flow
																					graph[v][u] += path_flow
																					__lowerCamelCase					:		Optional[int]		   =     parent[v]

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





# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__A  =				abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)


def    lowercase_   (   _lowerCamelCase:	List[Any]      ) ->      Union[str, Any]:



							'''simple docstring'''

							config.addinivalue_line(
							    "markers"						,   "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested"      )
							config.addinivalue_line(
							    "markers"						,   "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested"      )
							config.addinivalue_line("markers"						,   "is_pipeline_test: mark test to run only when pipelines are tested"      )
							config.addinivalue_line("markers"						,   "is_staging_test: mark test to run only in the staging environment"      )
							config.addinivalue_line("markers"						,   "accelerate_tests: mark test that require accelerate"      )
							config.addinivalue_line("markers"						,   "tool_tests: mark the tool tests that are run on their specific schedule"      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]      ) ->      Any:



							'''simple docstring'''

							from transformers.testing_utils import pytest_addoption_shared

							pytest_addoption_shared(_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Optional[int]      ) ->      Tuple:



							'''simple docstring'''

							from transformers.testing_utils import pytest_terminal_summary_main

							__lowerCamelCase					:		Any		   =     terminalreporter.config.getoption("--make-reports"      )
							if make_reports:
														pytest_terminal_summary_main(_lowerCamelCase						,   id=_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	Tuple      ) ->      Dict:



							'''simple docstring'''

							if exitstatus == 5:
														__lowerCamelCase					:		Optional[int]		   =     0


# Doctest custom flag to ignore output.
__A  =				doctest.register_optionflag('''IGNORE_RESULT''')

__A  =				doctest.OutputChecker
class  _snake_case     (					a__		):






						def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any							,					UpperCAmelCase      :			int    ):
													if IGNORE_RESULT & optionflags:
																				return True
													return OutputChecker.check_output(self							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

__A  =				CustomOutputChecker
__A  =				HfDoctestModule







__A  =				HfDocTestParser