





__UpperCAmelCase       :   List[Any]				       =							[
    [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],
]







def 			A__							(    SCREAMING_SNAKE_CASE__					,					SCREAMING_SNAKE_CASE__					,					SCREAMING_SNAKE_CASE__					,					SCREAMING_SNAKE_CASE__)   ->    Any:
  # Return True if there is node that has not iterated.
  __snake_case:						Union[str, Any]   =						[False] * len(__UpperCAmelCase)
  __snake_case:						List[str]   =						[s]
  __snake_case:						int   =						True

  while queue:
    __snake_case:						Any   =						queue.pop(0)
    for ind in range(len(graph[u])):
      if visited[ind] is False and graph[u][ind] > 0:
        queue.append(__UpperCAmelCase)
        __snake_case:						int   =						True
        __snake_case:						Optional[int]   =						u

  return visited[t]







def 			A__							(    SCREAMING_SNAKE_CASE__					,					SCREAMING_SNAKE_CASE__					,					SCREAMING_SNAKE_CASE__)   ->    Union[str, Any]:
  __snake_case:						Union[str, Any]   =						[-1] * (len(__UpperCAmelCase))
  __snake_case:						Any   =						0
  __snake_case:						Optional[int]   =						[]
  __snake_case:						Any   =						[i[:] for i in graph]  # Record original cut, copy.
  while bfs(__UpperCAmelCase					,					__UpperCAmelCase					,					__UpperCAmelCase					,					__UpperCAmelCase):
    __snake_case:						List[Any]   =						float("""Inf""")
    __snake_case:						int   =						sink

    while s != source:
      # Find the minimum value in select path
      __snake_case:						List[str]   =						min(__UpperCAmelCase					,					graph[parent[s]][s])
      __snake_case:						Dict   =						parent[s]

    max_flow += path_flow
    __snake_case:						Any   =						sink

    while v != source:
      __snake_case:						Optional[int]   =						parent[v]
      graph[u][v] -= path_flow
      graph[v][u] += path_flow
      __snake_case:						List[str]   =						parent[v]

  for i in range(len(__UpperCAmelCase)):
    for j in range(len(graph[0])):
      if graph[i][j] == 0 and temp[i][j] > 0:
        res.append((i, j))

  return res


if __name__ == "__main__":
      print(mincut(test_graph, source=0, sink=5))













def 		lowerCAmelCase_    (  __UpperCAmelCase:			int = 100_0000      )      ->	int:
    UpperCamelCase__							:				str          =      limit + 1
    UpperCamelCase__							:				List[str]          =      [0] * limit
    for first_term in range(1		,   __UpperCAmelCase      ):
        for n in range(__UpperCAmelCase		,   __UpperCAmelCase		,   __UpperCAmelCase      ):
            UpperCamelCase__							:				str          =      first_term + n / first_term
            if common_difference % 4:  # d must be divisble by 4
                continue
            else:
                common_difference /= 4
                if (
                    first_term > common_difference
                    and first_term < 4 * common_difference
                ):  # since x,y,z are positive integers
                    frequency[n] += 1  # so z>0 and a>d ,also 4d<a

    UpperCamelCase__							:				Any          =      sum(1 for x in frequency[1:limit] if x == 10      )

    return count


if __name__ == "__main__":
  print(F'''{solution() = }''')

