#include <vector>
#include <fstream>
#include <queue>
using namespace std;

#define MAX 1024
#define pb push_back
#define INF 0x3f3f3f3f


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

int C[MAX][MAX];
int F[MAX][MAX];
vector<int> G[MAX];
vector<bool> viz;
int T[MAX];
int n, m;
queue<int> Q;


void Read();
bool BF();

int main()
{
    Read();
    int flux = 0;
    int fmin;
    while( BF() )
    {

        for ( int j = 0; j < G[n].size(); ++j)
        {
            fmin = INF;
            int i = G[n][j];
            if ( C[i][n] == F[i][n] || !viz[i] )
                continue;
            T[n] = i;
            for ( int k = n; k != 1; k = T[k] )
                fmin = min(fmin, C[T[k]][k] - F[T[k]][k]);
            if ( fmin == 0 )
                continue;

            for ( int k = n; k != 1; k = T[k] )
                F[T[k]][k] += fmin, F[k][T[k]] -= fmin;
            flux += fmin;
        }
    }

    fout << flux;


    fin.close();
    fout.close();
    return 0;
}

void Read()
{
    fin >> n >> m;
    viz.resize(n + 1);
    int x, y, z;
    for ( ; m--; )
    {
        fin >> x >> y >> z;
        G[x].pb(y);
        G[y].pb(x);
        C[x][y] += z;
    }

}

bool BF()
{
    viz.assign(n + 1, false);
    viz[1] = true;
    Q.push(1);
    int i;
    while ( !Q.empty() )
    {
        i = Q.front();
        Q.pop();
        for ( int k = 0; k < G[i].size(); ++k )
        {
            int j = G[i][k];
            if ( viz[j] || C[i][j] == F[i][j] )
                continue;
            T[j] = i;
            Q.push(j);
            viz[j] = true;
        }

    }
    return viz[n];
}