#include <iostream>
#include <fstream>
#include <vector>
#include <deque>

#define Infinit 2000000000

using namespace std;

vector <int> G[1005];
int N, Flow[1005][1005], Father[1005], MaxFlow, Cap[1005][1005];
bool Viz[1005];

void Read ()
{
    ifstream fin ("maxflow.in");
    int M, X, Y, Z;
    fin >> N >> M;
    for (; M>0; --M)
    {
        fin >> X >> Y >> Z;
        G[X].push_back (Y);
        G[Y].push_back (X);
        Cap[X][Y]+=Z;
    }
    fin.close ();
}

void Type ()
{
    ofstream fout ("maxflow.out");
    fout << MaxFlow << "\n";
    fout.close ();
}

int BFS (int Start, int End)
{
    deque <int> Stiva;
    deque <int> :: iterator X;
    unsigned i;
    for (i=1; i<=N; ++i)
    {
        Viz[i]=false;
    }
    Viz[Start]=true;
    Stiva.push_back (Start);
    while (Stiva.size ()>0)
    {
        X=Stiva.begin ();
        for (i=0; i<G[*X].size (); ++i)
        {
            if ((Viz[G[*X][i]]==false)&&(Cap[*X][G[*X][i]]-Flow[*X][G[*X][i]]>0))
            {
                Stiva.push_back (G[*X][i]);
                Father[G[*X][i]]=*X;
                Viz[G[*X][i]]=true;
            }
        }
        Stiva.pop_front ();
    }
    if (Viz[End]==true)
    {
        return 1;
    }
    return 0;
}

inline int Min (int a, int b)
{
    if (a<b)
    {
        return a;
    }
    return b;
}

int main()
{
    unsigned i;
    int X, F, CurrentF;
    Read ();
    for (; BFS (1, N)!=0; MaxFlow+=F)
    {
        F=0;
        for (i=0; i<G[N].size (); ++i)
        {
            if ((Viz[G[N][i]]==true)&&(Cap[G[N][i]][N]-Flow[G[N][i]][N]>0))
            {
                Father[N]=G[N][i];
                CurrentF=Infinit;
                for (X=N; X>1; X=Father[X])
                {
                    CurrentF=Min (Cap[Father[X]][X]-Flow[Father[X]][X], CurrentF);
                }
                for (X=N; X>1; X=Father[X])
                {
                    Flow[Father[X]][X]+=CurrentF;
                    Flow[X][Father[X]]-=CurrentF;
                }
                F+=CurrentF;
            }
        }
    }
    Type ();
    return 0;
}