






"""simple docstring"""


from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
lowercase_								=	TypeVar('T', bound='Enum')


@unique
class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   A_		:      List[Any]							=					80
   A_		:      Dict							=					70
   A_		:      Optional[int]							=					60
   A_		:      Any							=					50
   A_		:      Dict							=					40
   A_		:      str							=					30
   A_		:      Tuple							=					20
   A_		:      Tuple							=					10





@unique
class    snake_case						(				_lowerCAmelCase		):


   '''simple docstring'''

   A_		:      Optional[int]							=					24
   A_		:      Any							=					21
   A_		:      Union[str, Any]							=					18
   A_		:      str							=					15
   A_		:      List[str]							=					12
   A_		:      str							=					9
   A_		:      List[str]							=					6
   A_		:      str							=					3
   A_		:      Any							=					2
   A_		:      Any							=					1
   A_		:      List[Any]							=					-1
   A_		:      str							=					-2
   A_		:      Tuple							=					-3
   A_		:      List[str]							=					-6
   A_		:      int							=					-9
   A_		:      List[Any]							=					-12
   A_		:      List[Any]							=					-15
   A_		:      Optional[int]							=					-18
   A_		:      Optional[Any]							=					-21
   A_		:      Optional[int]							=					-24


   @classmethod
   def 							_SCREAMING_SNAKE_CASE							(      cls					:	type[T]    ):

     '''simple docstring'''
     return {unit.name: unit.value for unit in cls if unit.value > 0}






   @classmethod
   def 							_SCREAMING_SNAKE_CASE							(      cls					:	type[T]    ):

     '''simple docstring'''
     return {unit.name: unit.value for unit in cls if unit.value < 0}





def    lowerCAmelCase							(       __UpperCamelCase					):




  """simple docstring"""







  __A		     =					SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
  for name_prefix, value_prefix in prefixes.items():
    __A		     =					value / (1_0**value_prefix)
    if numerical_part > 1:
      return f'{numerical_part!s} {name_prefix}'
  return str(__UpperCamelCase					)



def    lowerCAmelCase							(       __UpperCamelCase					):




  """simple docstring"""







  for prefix in BinaryUnit:
    __A		     =					value / (2**prefix.value)
    if numerical_part > 1:
      return f'{numerical_part!s} {prefix.name}'
  return str(__UpperCamelCase					)


if __name__ == "__main__":
       import doctest

       doctest.testmod()







lowerCAmelCase__							=			float("inf")






class     __magic_name__     :


 def __init__(    self		:			List[str]      ,    lowerCAmelCase__		:			Dict     )     ->   List[Any]:
   UpperCAmelCase          =	[0] * n
   UpperCAmelCase          =	[0] * n
   UpperCAmelCase          =	[0] * n
   UpperCAmelCase          =	[[] for _ in range(lowerCAmelCase__     )]


 def _UpperCamelCase						(    self		:			List[Any]      ,    lowerCAmelCase__		:			Tuple      ,    lowerCAmelCase__		:			Dict      ,    lowerCAmelCase__		:			str      ,    lowerCAmelCase__		:			Optional[Any]=0     )     ->   Any:
   self.adj[a].append([b, len(self.adj[b]     ), c, 0]     )
   self.adj[b].append([a, len(self.adj[a]     ) - 1, rcap, 0]     )


 def _UpperCamelCase						(    self		:			List[str]      ,    lowerCAmelCase__		:			Union[str, Any]      ,    lowerCAmelCase__		:			List[Any]      ,    lowerCAmelCase__		:			Any     )     ->   List[str]:
   if vertex == sink or not flow:
     return flow

   for i in range(self.ptr[vertex]      ,    len(self.adj[vertex]     )     ):
     UpperCAmelCase          =	self.adj[vertex][i]
     if self.lvl[e[0]] == self.lvl[vertex] + 1:
       UpperCAmelCase          =	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
     UpperCAmelCase          =	self.ptr[vertex] + 1
   return 0


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

       UpperCAmelCase          =	self.depth_first_search(lowerCAmelCase__      ,    lowerCAmelCase__      ,    lowerCAmelCase__     )
       while p:
         flow += p
         UpperCAmelCase          =	self.depth_first_search(lowerCAmelCase__      ,    lowerCAmelCase__      ,    lowerCAmelCase__     )

       if not self.lvl[sink]:
         break

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



