#include <iostream>
#include <fstream>
#include <deque>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;

const int NMAX = 1e3;

int flow[NMAX + 1][NMAX + 1];
vector <int> edges[NMAX + 1];
int previous[NMAX + 1];
deque <int> dq;

void reset() {
    memset( previous, 0, sizeof(previous) );
}
bool bfs( int source, int destination ) {
    reset();

    previous[source] = -1;
    dq.clear();
    dq.push_back( source );
    while ( !dq.empty() ) {
        int node = dq.front();
        dq.pop_front();

        if ( node == destination ) {
            return true;
        } else {
            for ( auto i : edges[node] ) {
                if ( flow[node][i] > 0 && !previous[i] ) {
                    dq.push_back( i );
                    previous[i] = node;
                }
            }
        }
    }
    return false;
}
int main() {
    ifstream fin( "maxflow.in" );
    ofstream fout( "maxflow.out" );
    int n, m, a, b, c, i, source, destination, maxflow, totalflow = 0;
    fin >> n >> m;

    for ( i = 0; i < m; i ++ ) {
        fin >> a >> b >> c;
        flow[a][b] = c;
        if ( !flow[b][a] ) {
            edges[a].push_back( b );
            edges[b].push_back( a );
        }
    }

    for ( i = 1; i <= n; i ++ ) {
        random_shuffle( edges[i].begin(), edges[i].end() );
    }
    source = 1;
    destination = n;
    while ( bfs( source, destination ) ) {
        maxflow = 0;
        for ( auto node : edges[destination] ) {
            if ( flow[node][destination] > 0 && previous[node] ) {
                maxflow = flow[node][destination];
                i = node;
                while ( i != source ) {
                    maxflow = min( maxflow, flow[previous[i]][i] );
                    i = previous[i];
                }
                totalflow += maxflow;

                flow[node][destination] -= maxflow;
                flow[destination][node] += maxflow;
                i = node;
                while ( i != source ) {
                    flow[previous[i]][i] -= maxflow;
                    flow[i][previous[i]] += maxflow;
                    i = previous[i];
                }
            }
        }
    }
    fout << totalflow;
    return 0;
}