#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];
deque <int> Stiva;


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> :: iterator X;
    unsigned i;
    int V;
    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)
        {
            V=G[*X][i];
            if ((Viz[V]==false)&&(Cap[*X][V]-Flow[*X][V]>0))
            {
                Stiva.push_back (V);
                Father[V]=*X;
                Viz[V]=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 (MaxFlow=0; BFS (1, N)!=0; MaxFlow+=F)
    {
        F=0;
        for (i=0; i<G[N].size (); ++i)
        {
            X=G[N][i];
            if ((Viz[X]==true)&&(Cap[X][N]-Flow[X][N]>0))
            {
                Father[N]=X;
                CurrentF=Infinit;
                for (X=N; X>1; X=Father[X])
                {
                    CurrentF=Min (Cap[Father[X]][X]-Flow[Father[X]][X], CurrentF);
                }
                if (CurrentF>0)
                {
                    for (X=N; X>1; X=Father[X])
                    {
                        Flow[Father[X]][X]+=CurrentF;
                        Flow[X][Father[X]]-=CurrentF;
                    }
                    F+=CurrentF;
                }
            }
        }
    }
    Type ();
    return 0;
}