#include <iostream>
#include <fstream>
#include <vector>
#include <bitset>

#define DN 1005
#define pb push_back
#define INF (1<<30)
using namespace std;

int C[DN][DN],t[DN],arb[DN],F[DN][DN],n,m,flow;
/// C - capacitate
/// F - folosit
vector<int> list[DN];
bitset<DN> viz;

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

bool bf()
{
    arb[0]=1;
    arb[1]=1; /// sursa e singurul nod din arborele bf
    viz&=0;
    viz[1]=1;
    for(int i=1;i<=arb[0];++i)
    {
        int nod = arb[i];
        if(nod == n ) continue;

        for(int j=0;j<list[nod].size();++j)
        {
            int next_nod = list[nod][j];
            if( C[nod][next_nod] == F[nod][next_nod] || viz[next_nod] ) continue;
            viz[ next_nod ] = true;
            arb[++arb[0]] = next_nod;
            t[next_nod] = nod;
        }
    }
    return viz[n];
}

void solve()
{
    bool exista_flux = true;
    while(exista_flux)
    {
        exista_flux = bf();
        for(int i=0;i<list[n].size();++i)
        {
            int nod = list[n][i] , fmin = INF ;
            if( C[nod][n] == F[nod][n] || !viz[ nod ] ) continue;
            t[ n ] = nod;

            for( nod = n; nod != 1 ; nod = t[nod])
                fmin = min(fmin, C[ t[nod] ][ nod ] - F[ t[nod] ][ nod ]);
            if(fmin==0) continue;

            for( nod = n; nod != 1 ; nod = t[nod])
            {
                F[ t[nod] ][ nod ]+=fmin;
                F[ nod ][ t[nod] ]-=fmin;
            }
            flow+=fmin;
        }
    }
    g<<flow;
}

void read()
{
    f>>n>>m;
    for(int i=1;i<=m;++i)
    {
        int a,b,c;
        f>>a>>b>>c;
        C[a][b]+=c;
        list[a].pb(b);
        list[b].pb(a);
    }
}

int main()
{
    read();
    solve();

    return 0;
}