


'''simple docstring'''



A__						:   str				=    [
    [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      UpperCAmelCase__   (      UpperCAmelCase_       :							Dict ,       UpperCAmelCase_       :							Any ,       UpperCAmelCase_       :							str ,       UpperCAmelCase_       :							Dict				)	->						int:
     # Return True if there is node that has not iterated.
     __lowerCamelCase  :      Optional[int]														=						[False] * len(UpperCAmelCase_				)
     __lowerCamelCase  :      List[Any]														=						[s]
     __lowerCamelCase  :      str														=						True

     while queue:
          __lowerCamelCase  :      Dict														=						queue.pop(0				)
          for ind in range(len(graph[u]				)				):
               if visited[ind] is False and graph[u][ind] > 0:
                    queue.append(UpperCAmelCase_				)
                    __lowerCamelCase  :      Tuple														=						True
                    __lowerCamelCase  :      List[str]														=						u

     return visited[t]



def      UpperCAmelCase__   (      UpperCAmelCase_       :							Any ,       UpperCAmelCase_       :							Optional[int] ,       UpperCAmelCase_       :							List[Any]				)	->						List[Any]:
     __lowerCamelCase  :      str														=						[-1] * (len(UpperCAmelCase_				))
     __lowerCamelCase  :      Union[str, Any]														=						0
     __lowerCamelCase  :      int														=						[]
     __lowerCamelCase  :      str														=						[i[:] for i in graph]  # Record original cut, copy.
     while bfs(UpperCAmelCase_ ,       UpperCAmelCase_ ,       UpperCAmelCase_ ,       UpperCAmelCase_				):
          __lowerCamelCase  :      Tuple														=						float('Inf'				)
          __lowerCamelCase  :      List[str]														=						sink

          while s != source:
               # Find the minimum value in select path
               __lowerCamelCase  :      Union[str, Any]														=						min(UpperCAmelCase_ ,       graph[parent[s]][s]				)
               __lowerCamelCase  :      Union[str, Any]														=						parent[s]

          max_flow += path_flow
          __lowerCamelCase  :      List[Any]														=						sink

          while v != source:
               __lowerCamelCase  :      Tuple														=						parent[v]
               graph[u][v] -= path_flow
               graph[v][u] += path_flow
               __lowerCamelCase  :      List[Any]														=						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))










'''simple docstring'''



def      UpperCAmelCase__   (      UpperCAmelCase_       :							int = 10_00				)	->						int:
     __lowerCamelCase  :      Union[str, Any]														=						3
     __lowerCamelCase  :      Dict														=						0
     while a < n:
          if a % 3 == 0 or a % 5 == 0:
               result += a
          elif a % 15 == 0:
               result -= a
          a += 1
     return result


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






