#include <fstream>
#include <vector>
#include <deque>
#define DIM 1010
using namespace std;

vector<int> L[DIM];
int C[DIM][DIM];
int F[DIM][DIM];
int T[DIM];
int U[DIM];
deque<int> q;

int n, m, i, j, minim, flux = 0,x,y,z,nod,p,u;

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

int bfs() {
    int gasit = 0;

    for (int i=1;i<=n;i++)
        U[i] = 0;
    U[1] = 1;
    q.push_back(1);
    while (!q.empty()) {
        nod = q.front();
        for (int i=0;i<L[nod].size();i++) {
            int vecin = L[nod][i];
            if (U[vecin] == 0 && C[nod][vecin] > F[nod][vecin]) {
                q.push_back(vecin);
                U[vecin] = 1;
                T[vecin] = nod;
                if (vecin == n)
                    gasit = 1;
            }

        }
        q.pop_front();

    }
    return gasit;

}

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()) {
        for (int i=0;i<L[n].size();i++) {
            p = L[n][i];
            if (C[p][n] > F[p][n] && U[p] == 1) {
                minim = C[p][n] - F[p][n];
                u = p;
                while (T[u] != 0) {
                    if ( C[ T[u] ][u] - F[ T[u] ][u] < minim) {
                        minim = C[ T[u] ][u] - F[ T[u] ][u];
                    }
                    u = T[u];
                }
                flux += minim;

                F[p][n] += minim;
                F[n][p] -= minim;

                u = p;
                while (T[u] != 0) {
                    F[ T[u] ][u] += minim;
                    F[ u ][ T[u] ] -= minim;
                    u = T[u];
                }

            }

        }

    }
    fout<<flux;
}