

"""simple docstring"""




def   lowerCAmelCase						(					__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      ):
 '''simple docstring'''





 UpperCAmelCase__					:  int					   =					[False] * len(__UpperCamelCase      )
 UpperCAmelCase__					:  Optional[Any]					   =					[]
 queue.append(__UpperCamelCase      )
 UpperCAmelCase__					:  str					   =					True

 while queue:
  UpperCAmelCase__					:  Tuple					   =					queue.pop(0      )
  for ind in range(len(graph[u]      )      ):
   if visited[ind] is False and graph[u][ind] > 0:
    queue.append(__UpperCamelCase      )
    UpperCAmelCase__					:  str					   =					True
    UpperCAmelCase__					:  Union[str, Any]					   =					u

 return visited[t]
def   lowerCAmelCase						(					__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      ):
 '''simple docstring'''





 UpperCAmelCase__					:  str					   =					[-1] * (len(__UpperCamelCase      ))
 UpperCAmelCase__					:  Tuple					   =					0
 while bfs(__UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase							,    __UpperCamelCase      ):
  UpperCAmelCase__					:  Any					   =					float("""Inf"""      )
  UpperCAmelCase__					:  List[str]					   =					sink

  while s != source:
   # Find the minimum value in select path
   UpperCAmelCase__					:  Tuple					   =					min(__UpperCamelCase							,    graph[parent[s]][s]      )
   UpperCAmelCase__					:  Tuple					   =					parent[s]

  max_flow += path_flow
  UpperCAmelCase__					:  Optional[int]					   =					sink

  while v != source:
   UpperCAmelCase__					:  Any					   =					parent[v]
   graph[u][v] -= path_flow
   graph[v][u] += path_flow
   UpperCAmelCase__					:  Optional[Any]					   =					parent[v]
 return max_flow


__UpperCAmelCase =				[
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

__UpperCAmelCase,		__UpperCAmelCase =				0, 5




print(ford_fulkerson(graph, source, sink))








"""simple docstring"""




__UpperCAmelCase =				'Tobias Carryer'

from time import time







class      __lowercase			:

  def __init__(  self		:			Union[str, Any]					,A		:			Dict					,A		:			Optional[int]					,A		:			Union[str, Any]					,A		:			int=int(time()    )    ):  # noqa: B008






   '''simple docstring'''
   UpperCAmelCase__					:  int					   =					multiplier
   UpperCAmelCase__					:  Union[str, Any]					   =					increment
   UpperCAmelCase__					:  Dict					   =					modulo
   UpperCAmelCase__					:  Tuple					   =					seed




  def    __lowercase       (  self		:			Dict    ):






   '''simple docstring'''
   UpperCAmelCase__					:  Any					   =					(self.multiplier * self.seed + self.increment) % self.modulo
   return self.seed


if __name__ == "__main__":
      # Show the LCG in action.
      __UpperCAmelCase =				LinearCongruentialGenerator(166_4525, 10_1390_4223, 2 << 31)
      while True:
            print(lcg.next_number())





