#include <bits/stdc++.h>

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

const int NMAX = 1e3 + 5;

int n, m, f[NMAX], ptr[NMAX], level[NMAX];

std :: vector < flowEdge > edges;
std :: vector < int > G[NMAX];

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

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

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

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

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

        for (int i = 0; i < G[u].size(); ++ i) {
            int v = edges[G[u][i]].v, cap = edges[G[u][i]].cap;

            if (f[v] == false && cap > 0) {
                Q.push(v);
                f[v] = true;
                level[v] = level[u] + 1;
            }
        }

        Q.pop();
    }

    return;
}

int DFS(int node, int pushed) {
    if (!pushed) {
        return 0;
    }

    if (node == n) {
        return pushed;
    }

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

        int v = edges[ind].v, cap = edges[ind].cap;

        if (level[v] == level[node] + 1 && cap > 0) {
            int r = DFS(v, std :: min(pushed, cap));

            if (r) {
                edges[ind].cap -= r;
                edges[ind ^ 1].cap += r;

                return r;
            }
        }
    }

    return 0;
}

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

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

        edges.push_back({u, v, cap});
        G[u].push_back(edges.size() - 1);

        edges.push_back({v, u, 0});
        G[v].push_back(edges.size() - 1);
    }

    BFS(1);

    long long flow = 0;
    int t;

    while (t = DFS(1, 1e9)) {
        for (int i = 1; i <= n; ++ i) {
            ptr[i] = 0;
        }

        flow += t;

        BFS(1);
    }

    fout << flow << "\n";

    return 0;
}