#include <bits/stdc++.h>

const int NMAX = 1e3 + 5;

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

int n, m, dist[NMAX], ptr[NMAX];

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

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

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

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

    Q.push(node);
    dist[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 (!dist[v] && cap) {
                dist[v] = 1 + dist[u];
                Q.push(v);
            }
        }

        Q.pop();
    }

    return dist[n];
}

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 u = edges[G[node][i]].v, cap = edges[G[node][i]].cap;

        if (cap && 1 + dist[node] == dist[u]) {
            int r = DFS(u, std :: min(pushed, cap));

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

                return r;
            }
        }
    }

    return 0;
}

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

    for (int i = 0, 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);
    }

    int flow = 0;

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

        int t;

        while (t = DFS(1, 1e9)) {
            flow += t;
        }
    }

    fout << flow;

    return 0;
}