#include <fstream>
#include <vector>
#include <queue>
#include <cstring>

#define NMAX 1005
#define INF (1<<30)

#define pb push_back
#define MIN(a,b) (a<b) ? a : b

using namespace std;

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

int N, M, x, y, cost, C[NMAX][NMAX], F[NMAX][NMAX], T[NMAX], MaxFlow, FlowCt, Nod;
vector< int > G[NMAX];
vector< int >::iterator Vecin;
bool USED[NMAX];
bool BF()
{
	int i;
	
    queue< int > Q;
    Q.push( 1 );
	
    memset( USED, false, sizeof(USED) );
	
    USED[ 1 ] = true;
	
    while( !Q.empty() )
    {
        int NOD = Q.front();
        
        if( NOD != N )
			for ( i = 0 ; i < G[ NOD ].size() ; i++ )
                if( !USED[ G[ NOD ][ i ] ] && F[NOD][G[ NOD ][ i ]] < C[NOD][G[ NOD ][ i ]] )
                {
                    USED[ G[ NOD ][ i ] ] = true;
                    Q.push( G[ NOD ][ i ] );
                    T[G[ NOD ][ i ]] = NOD;
                }
				Q.pop();
    }

    return USED[N];
}

int main()
{
	int i, j;
	
    memset( C, 0, sizeof(C) );
    memset( F, 0, sizeof(F) );

    in >> N >> M;
    while( M-- )
    {
        in >> x >> y >> cost;
        C[ x ][ y ] = cost;
        G[ x ].pb( y );
        G[ y ].pb( x );
    }

    MaxFlow = 0;
    while( BF() )
		for ( i = 0 ; i < G[ N ].size() ; i++ )
            if( USED[ G[ N ][ i ] ] && F[ G[ N ][ i ] ][N] < C[ G[ N ][ i ] ][ N ] )
            {
                T[ N ] = G[ N ][ i ];
                FlowCt = INF;
				
				Nod = N;
                //for( Nod = N; Nod != 1; Nod = T[Nod] )
				while( Nod != 1 )
				{
                    FlowCt = MIN( FlowCt, C[ T[Nod] ][ Nod ] - F[ T[Nod] ][ Nod ] );
					Nod = T[ Nod ];
				}

                if( FlowCt )
				{
					Nod = N;
                    //for( Nod = N; Nod != 1; Nod = T[Nod] )
					while( Nod != 1 )
                    {
						Nod = T[ Nod ];
                        F[ T[Nod] ][ Nod ] += FlowCt;
                        F[ Nod ][ T[Nod] ] -= FlowCt;
                    }
				}

                MaxFlow += FlowCt;
            }

    out << MaxFlow << '\n';

    return 0;
}