/// Ford-Fulkerson, O(M * L)
#include <fstream>
#include <vector>

using namespace std;

int n, m, i, j, k, flx, min1;
int bfs[1005], tata[1005], c[1005][1005], flux[1005][1005];
bool viz[1005];
vector<int> graf[1005];

int BFS() {
    for(i = 1; i <= n; i++)
        viz[i] = false;
    m = 1;
    bfs[0] = 1;
    viz[1] = true;  /// BFS in graful rezidual, plecand din 1
    for(i = 0; i < m; i++) {
        k = bfs[i];
        if(k != n)
            for(j = 0; j < graf[k].size(); j++)
                if(!viz[graf[k][j]] && flux[k][graf[k][j]] < c[k][graf[k][j]]) {   /// daca vecinul curent nu este vizitat si muchia nu este folosita la
                    viz[graf[k][j]] = true;                                         /// capacitate maxima
                    bfs[m++] = graf[k][j];
                    tata[graf[k][j]] = k;
                }
    }

    return viz[n];
}

int main() {
    ifstream f("maxflow.in");
    ofstream g("maxflow.out");

    f >> n >> m;
    while(m) {
        f >> i >> j >> k;

        graf[i].push_back(j);
        graf[j].push_back(i);   /// adaugam si muchia inversa in graf
        c[i][j] = k;    /// capacitatile muchiilor

        m--;
    }
    f.close();

    flx = 0;
    while(BFS())    /// cat timp exista un drum de la sursa la destinatie in graful rezidual
        for(i = 0; i < graf[n].size(); i++) {
            k = graf[n][i];
            if(viz[k] && flux[k][n] < c[k][n]) {    /// daca nodul a fost vizitat si pot mari fluxul
                tata[n] = k;    /// actualizez tatal lui n din bfs
                min1 = 2000000000;
                for(j = n; j != 1; j = tata[j])
                    min1 = min(min1, c[tata[j]][j] - flux[tata[j]][j]);
                if(min1 != 0) {
                    for(j = n; j != 1; j = tata[j]) {
                        flux[tata[j]][j] += min1;
                        flux[j][tata[j]] -= min1;
                    }

                    flx += min1;
                }
            }
        }

    g << flx << '\n';
    g.close();

    return 0;
}