#include <bits/stdc++.h>

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

const int NMAX = 2e5 + 5;

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

std :: vector < edge > edges;
std :: vector < int > G[NMAX];
int n, m, s, d, ptr[NMAX], level[NMAX], f[NMAX];

int flow;

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

    for (int i = 1; i <= n; ++ i)
        f[i] = false;

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

    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 (cap > 0 && f[v] == false) {
                level[v] = 1 + level[u];
                f[v] = true;
                Q.push(v);
            }
        }

        Q.pop();
    }

    return f[n];
}

int DFS(int node, int pushed) {
    if (node == d)
        return pushed;

    f[node] = true;

    for (int &i = ptr[node]; i < G[node].size(); ++ i) {
        int v = edges[G[node][i]].v, cap = edges[G[node][i]].cap;

        if (f[v] == false && cap > 0 && level[node] == level[v] - 1) {
            int t = DFS(v, std :: min(pushed, cap));

            if (t > 0) {
                edges[G[node][i]].cap -= t;
                edges[G[node][i] ^ 1].cap += t;
                return t;
            }
        }
    }

    return 0;
}

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

    s = 1;
    d = n;

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

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

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

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

        int t;

        for (int i = 1; i <= n; ++ i)
            f[i] = false;

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

    fout << flow << "\n";

    return 0;
}