from collections import deque
import math

def read_gen(fname):
    with open(fname, 'rt') as fin:
        for line in fin:
            for val in line.split():
                yield int(val)

def bfs(g, c, source, drain):

    prev = {}
    used = set()

    dq = deque()
    dq.append(source)
    prev[source] = source
    used.add(source)
    
    while len(dq) > 0:
        node = dq.popleft()
        for x in g[node]:
            if x not in used and c[node][x] > 0:
                prev[x] = node
                used.add(x)
                dq.append(x)
    return prev
    

def solve(g, c, source, drain):

    max_flow = 0

    while True:
        prev = bfs(g, c, source, drain)
        if drain not in prev:
            break

        node = drain
        flow = math.inf

        while node != prev[node]:
            flow = min(flow, c[prev[node]][node])
            node = prev[node]
        
        node = drain

        while node != prev[node]:
            c[prev[node]][node] -= flow
            c[node][prev[node]] += flow
            node = prev[node]

        max_flow += flow
    
    return max_flow
    
if __name__ == "__main__":
    
    it = read_gen('grader_test6.in')
    n, m = next(it), next(it)
    g = {x: [] for x in range(1, n + 1)}
    c = [[0 for j in range(0, n + 1)] for _ in range(0, n + 1)]

    for _ in range(m):
        x, y, z = next(it), next(it), next(it)
        g[x].append(y)
        g[y].append(x)
        c[x][y] += z

    max_flow = solve(g, c, 1, n)

    with open('maxflow.out', 'wt') as fout:
        fout.write('{}\n'.format(max_flow))