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

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;

int fluxmaxim=0;

int t[1001];

int bf()
{
    queue <int> q;

    for(int i=1; i<=n; i++)
    {
        viz[i]=false;
        t[i]=-1;
    }

    q.push(1);

    while(!q.empty())
    {
        int nod;

        nod=q.front(); q.pop();

        if(nod==n)
            return 1;

        viz[nod]=true;

        for(int i=0; i<gr[nod].v.size(); i++)
        {
            int x=gr[nod].v[i];
            if(viz[x]==false)
            {
                int valrez;

                if(g[nod][x].inv==false)
                    valrez=g[nod][x].cap-g[nod][x].f;
                else
                    valrez=g[nod][x].f;

                if(valrez>0)
                {
                    t[x]=nod;
                    viz[x]=true;
                    q.push(x);
                }
            }
        }
    }
    return 0;
}

void flux(int epsilon)
{
    for(int i=n; t[i]!=-1; i=t[i])
    {
        int x, y;

        x=t[i];
        y=i;

        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;
        }
    }

    fluxmaxim+=epsilon;
}

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(bf()==1)
    {
        cr=INT_MAX;

        for(int i=n; t[i]!=-1; i=t[i])
        {
            int x=t[i];

            int valrez;

            if(g[x][i].inv==false)
                    valrez=g[x][i].cap-g[x][i].f;
                else
                    valrez=g[x][i].f;

            cr=min(cr, valrez);
        }

        flux(cr);
        cr=0;
    }

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

    fout << fluxmaxim;

    return 0;
}