#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <string.h>
using namespace std;
#define nmax 1005
#define INF 2000000000

vector<int> G[nmax];
int C[nmax][nmax], F[nmax][nmax], viz[nmax], tata[nmax];
int N, M;

queue<int> Q;

void citire ()
{
    int i, x, y, z;
    ifstream fin("maxflow.in");
    fin >> N >> M;
    for (i = 1; i <= M; ++i)
    {
        fin >> x >> y >> z;
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y] += z;
        F[x][y] = F[y][x] = 0;
    }
}

int bfs ()
{
    int i, nod, urm;
    memset(viz, 0, sizeof(viz));
    Q.push(1); viz[1] = 1;
    while ( !Q.empty() )
    {
        nod = Q.front(); Q.pop();
        for (i = 0; i < G[nod].size (); ++i)
        {
            urm = G[nod][i];
            if ( !viz[urm] && C[nod][urm] > F[nod][urm]) {viz[urm] = 1; tata[urm] = nod; Q.push(urm); }
        }
    }
    return viz[N];
}

void solve ()
{
    int i, j, fmin, flux, urm;
    for (flux = 0; bfs(); )
    {
        fmin = INF;
        for (i = 0; i < G[N].size (); ++i)
        {
            urm = G[N][i];
            if (viz[urm] && C[urm][N] > 0)
            {
                fmin = C[urm][N] - F[urm][N];
                for (j = urm; j > 1; j = tata[j]) fmin = min(fmin, C[tata[j]][j] - F[tata[j]][j]);
                F[urm][N] += fmin;
                F[N][urm] -= fmin;
                for (j = urm; j > 1; j = tata[j]) { F[tata[j]][j] +=fmin; F[j][tata[j]] -= fmin; }
                flux += fmin;
            }
        }
    }
    ofstream fout("maxflow.out");
    fout << flux << "\n";
}

int main ()
{
    citire ();
    solve ();
    return 0;
}