#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

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

const int N_MAX = 1002;
const int INF = 1000000000;

int N, M, Source, Dest;
vector<int> Edges[N_MAX];
int Capacity[N_MAX][N_MAX], Flow[N_MAX][N_MAX];
int Q[N_MAX], T[N_MAX], level[N_MAX], urm[N_MAX];

bool BFS() {
    int st = 1, dr = 0;
    Q[++dr] = Source;
    for ( int i = 1; i <= N; ++i )
        level[i] = -1;  //nevizitat
    level[Source] = 0;

    while( st <= dr ) {
        int x = Q[st++];
        for( auto y : Edges[x] )
            if( level[y] == -1 && Capacity[x][y] > Flow[x][y] ) {
                level[y] = level[x] + 1;
                Q[++dr] = y;
            }
    }

    if( level[Dest] == -1 )
        return false;
    return true;
}

int DFS( int x, int f ) {
    if( x == Dest )
        return f;

    //daca nu ajungem nicaieri pe aceasta cale, o blocam (trecand peste - ++urm[x]), ca sa nu mai venim din nou pe aici!! optimizare importanta
    for( ; urm[x] < Edges[x].size(); ++urm[x]) {
        int y = Edges[x][urm[x]];
        int rem = Capacity[x][y] - Flow[x][y];      //capacitatea ramasa
        if( rem > 0 && level[y] == level[x] + 1 ) { //parcurgem graful nivelat
            int bottleneck = min(f, rem);
            bottleneck = DFS( y, bottleneck );
            if( bottleneck > 0 ) {
                Flow[x][y] += bottleneck;
                Flow[y][x] -= bottleneck;
                return bottleneck;  //din cauza returnarii fortate, trebuie sa apelam de mai multe ori DFS(Source) mai jos!
            }
        }
    }

    return 0;
}

int main() {
    int x, y, c;
    in >> N >> M;
    Source = 1, Dest = N;
    for( int i = 1; i <= M; ++i ) {
        in >> x >> y >> c;
        Edges[x].push_back( y );
        Capacity[x][y] = c;
        Edges[y].push_back( x );
    }

    //construim la fiecare pas graful nivelat
    int maxflow = 0;
    while( BFS() ) {
        fill( urm + 1, urm + N + 1, 0 );

        for( int f = DFS( Source, INF ); f; f = DFS( Source, INF ) )
            maxflow += f;
    }

    out << maxflow;

    return 0;
}