

"""simple docstring"""





_a				   =							float('inf')




class       _lowerCAmelCase						:







 """simple docstring"""







 def __init__(    self							:    str,      UpperCAmelCase__							:    Union[str, Any]			):
    __lowercase			=		[0] * n
    __lowercase			=		[0] * n
    __lowercase			=		[0] * n
    __lowercase			=		[[] for _ in range(_snake_case			)]


 def       _lowercase				(    self							:    List[str],      UpperCAmelCase__							:    Optional[int],      UpperCAmelCase__							:    Optional[int],      UpperCAmelCase__							:    str,      UpperCAmelCase__							:    List[Any]=0			):
    self.adj[a].append([b, len(self.adj[b]			), c, 0]			)
    self.adj[b].append([a, len(self.adj[a]			) - 1, rcap, 0]			)


 def       _lowercase				(    self							:    Optional[Any],      UpperCAmelCase__							:    str,      UpperCAmelCase__							:    Any,      UpperCAmelCase__							:    Optional[int]			):
    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],      _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
       __lowercase			=		self.ptr[vertex] + 1
    return 0



 def       _lowercase				(    self							:    List[Any],      UpperCAmelCase__							:    Union[str, Any],      UpperCAmelCase__							:    Optional[int]			):
    __lowercase			=		0, source
    for l in range(3_1			):  # noqa: E741  l = 30 maybe faster for random data
       while True:
          __lowercase			=		[0] * len(self.q			), [0] * len(self.q			)
          __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]) >> (3_0 - l):
                   __lowercase			=		e[0]
                   qe += 1
                   __lowercase			=		self.lvl[v] + 1

          __lowercase			=		self.depth_first_search(_snake_case,      _snake_case,      _snake_case			)
          while p:
             flow += p
             __lowercase			=		self.depth_first_search(_snake_case,      _snake_case,      _snake_case			)

          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						(						UpperCamelCase_  : float,    UpperCamelCase_  : float)			->		float:
   '''simple docstring'''


   __lowercase			=		float()
   try:
      __lowercase			=		mass * acceleration
   except Exception:
      return -0.0
   return force


if __name__ == "__main__":
   import doctest

   # run doctest
   doctest.testmod()

   # demo
   _a				   =							12.5
   _a				   =							10
   _a				   =							newtons_second_law_of_motion(mass, acceleration)
   print('The force is ', force, 'N')




