#include <bits/stdc++.h>

const int NMAX = 1e3 + 5;

struct flowEdge {
    int u, v, cap;
};

bool ok;
int n, m, flow, t[NMAX], ptr[NMAX], level[NMAX], f[NMAX], pos[NMAX];
std :: vector < flowEdge > edges;
std :: vector < int > G[NMAX];

std :: ifstream fin("maxflow.in");
std :: ofstream fout("maxflow.out");

bool BFS(int node) {
    std :: queue < int > Q;

    for (int i = 0; i < n; ++ i)
        level[i] = -1;

    Q.push(node);
    level[node] = 1;

    while (!Q.empty()) {
        int u = Q.front();

        for (int i = 0; i < G[u].size(); ++ i) {
            int x = G[u][i];

            if (edges[x].cap > 0 && level[edges[x].v] == -1) {
                level[edges[x].v] = level[u] + 1;
                Q.push(edges[x].v);
            }
        }

        Q.pop();
    }

    return (level[n - 1] != -1);
}

void DFSUtil(int node) {
    if (node == n - 1) {
        ok = true;
        return;
    }
    else
        if (ok == true)
            return;
        else {
            f[node] = true;

            for (int &i = ptr[node]; i < G[node].size(); ++ i) {
                int x = G[node][i];

                if (f[edges[x].v] == false && level[edges[x].v] == level[node] + 1 && edges[x].cap > 0) {
                    t[edges[x].v] = node;
                    pos[edges[x].v] = x;
                    DFSUtil(edges[x].v);
                }
            }
        }

    return;
}

bool DFS(int node) {
    ok = false;

    for (int i = 0; i < n; ++ i) {
        t[i] = -1;
        pos[i] = -1;
        f[i] = false;
    }

    DFSUtil(node);

    return (t[n - 1] != -1);
}

int main() {
    fin >> n >> m;

    for (int i = 0, u, v, f; i < m; ++ i) {
        fin >> u >> v >> f;

        -- u, -- v;

        int x = edges.size();

        edges.push_back({u, v, f});
        edges.push_back({v, u, 0});

        G[u].push_back(x);
        G[v].push_back(x + 1);
    }

    while (BFS(0)) {
        for (int i = 0; i < n; ++ i)
            ptr[i] = 0;

        while (DFS(0)) {
            int x = n - 1, Min = (1 << 30);

            while (t[x] != -1) {
                Min = std :: min(Min, edges[pos[x]].cap);

                x = t[x];
            }

            x = n - 1;

            while (t[x] != -1) {
                edges[pos[x]].cap -= Min;
                edges[pos[x] ^ 1].cap += Min;

                x = t[x];
            }

            flow += Min;
        }
    }

    fout << flow << "\n";

    return 0;
}