






'''simple docstring'''





_UpperCamelCase		:		List[Any]								=			float('inf')


class 				snake_case__     :




					def __init__(       self       :						Dict							,				_A       :						Tuple     )  ->    List[Any]:
								UpperCAmelCase_     :   Tuple       =   [0] * n
								UpperCAmelCase_     :   str       =   [0] * n
								UpperCAmelCase_     :   str       =   [0] * n
								UpperCAmelCase_     :   Optional[Any]       =   [[] for _ in range(_A     )]




					def 						A     (       self       :						Dict							,				_A       :						Optional[int]							,				_A       :						str							,				_A       :						Union[str, Any]							,				_A       :						Optional[Any]=0     )  ->    Optional[int]:
								self.adj[a].append([b, len(self.adj[b]     ), c, 0]     )
								self.adj[b].append([a, len(self.adj[a]     ) - 1, rcap, 0]     )




					def 						A     (       self       :						Any							,				_A       :						List[str]							,				_A       :						str							,				_A       :						List[Any]     )  ->    Optional[int]:
								if vertex == sink or not flow:
											return flow

								for i in range(self.ptr[vertex]							,				len(self.adj[vertex]     )     ):
											UpperCAmelCase_     :   Optional[int]       =   self.adj[vertex][i]
											if self.lvl[e[0]] == self.lvl[vertex] + 1:
														UpperCAmelCase_     :   Union[str, Any]       =   self.depth_first_search(e[0]							,				_A							,				min(_A							,				e[2] - e[3]     )     )
														if p:
																	self.adj[vertex][i][3] += p
																	self.adj[e[0]][e[1]][3] -= p
																	return p
											UpperCAmelCase_     :   List[Any]       =   self.ptr[vertex] + 1
								return 0





					def 						A     (       self       :						int							,				_A       :						Optional[int]							,				_A       :						Optional[int]     )  ->    str:
								UpperCAmelCase_  ,     UpperCAmelCase_     :   Union[str, Any]       =   0, source
								for l in range(31     ):  # noqa: E741  l = 30 maybe faster for random data
											while True:
														UpperCAmelCase_  ,     UpperCAmelCase_     :   Optional[Any]       =   [0] * len(self.q     ), [0] * len(self.q     )
														UpperCAmelCase_  ,     UpperCAmelCase_  ,     UpperCAmelCase_     :   Union[str, Any]       =   0, 1, 1
														while qi < qe and not self.lvl[sink]:
																	UpperCAmelCase_     :   List[str]       =   self.q[qi]
																	qi += 1
																	for e in self.adj[v]:
																				if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
																							UpperCAmelCase_     :   Optional[Any]       =   e[0]
																							qe += 1
																							UpperCAmelCase_     :   Optional[int]       =   self.lvl[v] + 1

														UpperCAmelCase_     :   List[Any]       =   self.depth_first_search(_A							,				_A							,				_A     )
														while p:
																	flow += p
																	UpperCAmelCase_     :   int       =   self.depth_first_search(_A							,				_A							,				_A     )

														if not self.lvl[sink]:
																	break

								return flow
_UpperCamelCase		:		Optional[int]								=			Dinic(10)
_UpperCamelCase		:		Optional[int]								=			0
_UpperCamelCase		:		Dict								=			9
for vertex in range(1, 5):
						graph.add_edge(source, vertex, 1)
for vertex in range(5, 9):
						graph.add_edge(vertex, sink, 1)
for vertex in range(1, 5):
						graph.add_edge(vertex, vertex + 4, 1)

# Now we can know that is the maximum flow(source -> sink)
print(graph.max_flow(source, sink))










'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_tokenizers_available


_UpperCamelCase		:		str								=			{}

try:
						if not is_sentencepiece_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_UpperCamelCase		:		List[Any]								=			['MBart50Tokenizer']

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_UpperCamelCase		:		List[str]								=			['MBart50TokenizerFast']


if TYPE_CHECKING:
						try:
												if not is_sentencepiece_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mbartaa import MBartaaTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mbartaa_fast import MBartaaTokenizerFast

else:
						import sys

						_UpperCamelCase		:		Optional[int]								=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


