#include <fstream>
#include <bitset>
#include <vector>
#define DIM 1003
using namespace std;

int C[DIM][DIM];
int F[DIM][DIM];
vector <int> L[DIM];
int c[DIM], t[DIM];
int flux, minim, n, nod, vec, m, x, y, z;

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

bitset<DIM> b;

int bfs(int s) {
    b.reset();
    b[s] = 1;
    int p = 1, u = 1;
    c[1] = s;
    while (p<=u) {
        nod = c[p];
        for (int i=0;i<L[nod].size();i++) {
            vec = L[nod][i];
            if (b[vec] == 0 && C[nod][vec] > F[nod][vec]) {
                c[++u] = vec;
                b[vec] = 1;
                t[vec] = nod;
                if (vec == n)
                    return 1;
            }
        }
        p++;
    }
    return 0;
}

int main() {
    fin>>n>>m;
    for (int i=1;i<=m;i++) {
        fin>>x>>y>>z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y] = z;
    }

    while (bfs(1)) {
        // saturam toate drumurile ce pornesc din 1 si ajung pe muchii nesaturate in vecini ai destinatiei
        // vom parcurge aceste drumuri in sens invers

        for (int i=0;i<L[n].size();i++) {
            int fr = L[n][i];
            if (b[fr] == 1 && C[fr][n] > F[fr][n]) {
                minim = C[fr][n] - F[fr][n];

                while (fr != 1) {
                    minim = min(minim, C[ t[fr] ][fr] - F[ t[fr] ][fr] );
                    fr = t[fr];
                }

                flux += minim;

                fr = L[n][i];
                F[fr][n] += minim;
                F[n][fr] -= minim;
                while (fr != 1) {
                    F[ t[fr] ][fr] += minim;
                    F[fr][ t[fr] ] -= minim;
                    fr = t[fr];
                }
            }

        }
    }


    fout<<flux;

    return 0;
}