#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], next[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;

    for(auto y : Edges[x]) {
        int rem = Capacity[x][y] - Flow[x][y];      //capacitatea ramasa
        if(rem > 0 && level[y] == level[x] + 1) { //parcurgem graful nivelat
            int bottleneck = DFS(y, min(f, rem));
            if(bottleneck > 0) {
                Flow[x][y] += bottleneck;
                Flow[y][x] -= bottleneck;
                return bottleneck;
            }

        }
    }

    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( next + 1, next + N + 1, 0 );

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

    out << maxflow;

    return 0;
}