#include <bits/stdc++.h>

using namespace std;

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

class Flow {
public:
    struct Edge {
        int from, to, flow;
    };

    vector <Edge> edges;
    vector < vector < int > > adia;
    vector < int > tata;
    int S, D, n;

    void AddEdge(int from, int to, int flow) {
        adia[from].push_back(edges.size());
        edges.push_back({from, to, flow});
        adia[to].push_back(edges.size());
        edges.push_back({to, from, 0});
    }

    bool bfs() {
        fill(tata.begin(), tata.end(), -1);

        vector < int > q = { S };
        tata[S] = -2;
        for (int it = 0; it < q.size(); ++it) {
            int nod = q[it];

            for (auto i : adia[nod]) {
                if (edges[i].flow && tata[edges[i].to] == -1) {
                    tata[edges[i].to] = i;
                    q.push_back(edges[i].to);
                }
            }
        }

        return (tata[D] != -1);
    }

    int push() {
        int ans(0);
        for (auto i : adia[D]) {
            int vmin(1e9 + 7);
            tata[D] = i ^ 1;
            if (edges[i ^ 1].flow == 0)
                continue;
            for (int nod = D; nod != S; nod = edges[tata[nod]].from)
                vmin = min(vmin, edges[tata[nod]].flow);
            assert(vmin);

            for (int nod = D; nod != S; nod = edges[tata[nod]].from) {
                edges[tata[nod]].flow -= vmin;
                edges[tata[nod] ^ 1].flow += vmin;
            }
            ans += vmin;
        }

        return ans;
    }

    int MaxFlow() {
        int ans(0);

        while (bfs())
            ans += push();
        return ans;
    }

    Flow() { }
    Flow(int S, int D, int n) : S(S), D(D), n(n), adia(n + 1), tata(n + 1) { }
};

int main()
{
    int n, m, a, b, c;
    fin >> n >> m;
    Flow fluxboi(1, n, n);
    while (m--) {
        fin >> a >> b >> c;
        fluxboi.AddEdge(a, b, c);
    }

    fout << fluxboi.MaxFlow();
    return 0;
}