
'''simple docstring'''



__A       =      float("inf")





class      A							:



			def __init__(   self    ,       lowerCamelCase__    )     ->						List[Any]:




									'''simple docstring'''



									lowercase__								=    [0] * n
									lowercase__								=    [0] * n
									lowercase__								=    [0] * n
									lowercase__								=    [[] for _ in range(lowerCamelCase__    )]



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__=0    )     ->						List[str]:




									'''simple docstring'''



									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    ,       lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    )     ->						Dict:




									'''simple docstring'''



									if vertex == sink or not flow:
															return flow

									for i in range(self.ptr[vertex]    ,       len(self.adj[vertex]    )    ):
															lowercase__								=    self.adj[vertex][i]
															if self.lvl[e[0]] == self.lvl[vertex] + 1:
																					lowercase__								=    self.depth_first_search(e[0]    ,       lowerCamelCase__    ,       min(lowerCamelCase__    ,       e[2] - e[3]    )    )
																					if p:
																											self.adj[vertex][i][3] += p
																											self.adj[e[0]][e[1]][3] -= p
																											return p
															lowercase__								=    self.ptr[vertex] + 1
									return 0



			def A__	(   self    ,       lowerCamelCase__    ,       lowerCamelCase__    )     ->						Dict:




									'''simple docstring'''



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

																					lowercase__								=    self.depth_first_search(lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    )
																					while p:
																											flow += p
																											lowercase__								=    self.depth_first_search(lowerCamelCase__    ,       lowerCamelCase__    ,       lowerCamelCase__    )

																					if not self.lvl[sink]:
																											break

									return flow
__A       =      Dinic(10)
__A       =      0
__A       =      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'''



def 	_A						(							lowercase__		):
						return " ".join(sorted(set(sentence.split()		)		)		)


if __name__ == "__main__":
				import doctest

				doctest.testmod()






