#include <fstream>
#include <vector>
#include <climits>

using namespace std;

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

struct muchie
{
    int ext=-1;
    int f=0;
    int cap;
    bool inv=false;
};

struct nod
{
    vector <int> v;
};

nod gr[1001];
muchie g[1001][1001];
bool viz[1001];

struct pereche
{
    int i;
    int j;
};

vector <pereche> v;

int cr=0;

int n, m;

bool sem=false;

int fluxmaxim=0;

void df(int nod, int capr)
{
    if(nod!=n)
    {
        viz[nod]=true;

        for(int j=0; j<gr[nod].v.size(); j++)
        {
            int i=gr[nod].v[j];
            if(viz[i]==false && g[nod][i].ext==1)
            {
                int valrez;
                if(g[nod][i].inv==false)
                    valrez=g[nod][i].cap-g[nod][i].f;
                else
                    valrez=g[nod][i].f;

                if(valrez>0)
                {
                    capr=min(capr, valrez);

                    pereche x;
                    x.i=nod; x.j=i;
                    v.push_back(x);

                    df(i, capr);

                    if(sem==false)
                    {
                        v.pop_back();
                    }
                    else
                        return;
                }
            }
        }
    }
    else
    {
        cr=capr;
        sem=true;
        return;
    }
}

void flux(int epsilon)
{
    for(int i=0; i<v.size(); i++)
    {
        int x, y;

        x=v[i].i;
        y=v[i].j;

        if(g[x][y].inv==false)
        {
            g[x][y].f+=epsilon;
            g[y][x].f+=epsilon;
        }
        else
        {
            g[x][y].f-=epsilon;
            g[y][x].f-=epsilon;
        }
    }

    v.clear();
    for(int i=1; i<=n; i++)
        viz[i]=false;
    fluxmaxim+=epsilon;
    sem=false;
}

int main()
{
    fin >> n >> m;

    for(int i=1; i<=m; i++)
    {
        int x, y, cap;

        fin >> x >> y >> cap;

        g[x][y].cap=cap;
        g[x][y].ext=1;
        g[y][x]=g[x][y];
        g[y][x].inv=true;

        gr[x].v.push_back(y);
        gr[y].v.push_back(x);
    }

    while(true)
    {
        df(1, INT_MAX);

        if(v.size()==0)
            break;

//        for(int i=0; i<v.size(); i++)
//            fout << v[i].i << " " << v[i].j << '\n';
//
//        fout << '\n' << '\n';

        flux(cr);
        cr=0;
    }

    fout << fluxmaxim;

    return 0;
}