code: 
  
  
  
  
  """simple docstring"""
  
  
  
  SCREAMING_SNAKE_CASE       = float("inf")
  
  
  
  
  class 			UpperCAmelCase_						:
  
  
  
  
      def __init__(					self		: Any			,				snake_case_		: List[str]   )   ->							Optional[Any]:
  
  
  
  
       '''simple docstring'''
  
       A__ =       [0] * n
       A__ =       [0] * n
       A__ =       [0] * n
       A__ =       [[] for _ in range(snake_case_   )]
  
  
  
  
      def 							__magic_name__							(					self		: Union[str, Any]			,				snake_case_		: Optional[int]			,				snake_case_		: str			,				snake_case_		: str			,				snake_case_		: Optional[Any]=0   )   ->							Optional[Any]:
  
  
  
  
       '''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 							__magic_name__							(					self		: List[Any]			,				snake_case_		: Tuple			,				snake_case_		: Union[str, Any]			,				snake_case_		: List[str]   )   ->							Dict:
  
  
  
  
       '''simple docstring'''
  
       if vertex == sink or not flow:
        return flow
  
       for i in range(self.ptr[vertex]			,				len(self.adj[vertex]   )   ):
        A__ =       self.adj[vertex][i]
        if self.lvl[e[0]] == self.lvl[vertex] + 1:
         A__ =       self.depth_first_search(e[0]			,				snake_case_			,				min(snake_case_			,				e[2] - e[3]   )   )
         if p:
          self.adj[vertex][i][3] += p
          self.adj[e[0]][e[1]][3] -= p
          return p
        A__ =       self.ptr[vertex] + 1
       return 0
  
  
  
  
      def 							__magic_name__							(					self		: Any			,				snake_case_		: Optional[Any]			,				snake_case_		: List[str]   )   ->							int:
  
  
  
  
       '''simple docstring'''
  
       A__,   A__ =       0, source
       for l in range(31   ):  # noqa: E741  l = 30 maybe faster for random data
        while True:
         A__,   A__ =       [0] * len(self.q   ), [0] * len(self.q   )
         A__,   A__,   A__ =       0, 1, 1
         while qi < qe and not self.lvl[sink]:
          A__ =       self.q[qi]
          qi += 1
          for e in self.adj[v]:
           if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
            A__ =       e[0]
            qe += 1
            A__ =       self.lvl[v] + 1
  
         A__ =       self.depth_first_search(snake_case_			,				snake_case_			,				snake_case_   )
         while p:
          flow += p
          A__ =       self.depth_first_search(snake_case_			,				snake_case_			,				snake_case_   )
  
         if not self.lvl[sink]:
          break
  
       return flow
  
  
  
  
  
  
  SCREAMING_SNAKE_CASE       = Dinic(10)
  SCREAMING_SNAKE_CASE       = 0
  SCREAMING_SNAKE_CASE       = 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))
  
  
  
  
  
  
style_context: 
  
  
  
  
  """simple docstring"""
  
  
  
  def 						_SCREAMING_SNAKE_CASE     (							lowercase_		)		->	str:
   return " ".join(sorted(set(sentence.split()		)		)		)
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
  
  
  
  
  
  