#include <fstream>
#include <cstdio>
#include <queue>
#include <cstring>
#define minimul(a,b) ((a>b)?b:a)
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");

struct nod{
    int x;
    nod*urm;
}*v[1005],*p;

int n,m,i,j,a,b,c,fluxmaxim;
int capacitate[1005][1005],flux[1005][1005],/*coada[1005],*/in=1,sf=0,viz[1005],tata[1005];
queue<int> coada;

int bfs()
{
    memset(viz,0,sizeof(viz));
    memset(tata,0,sizeof(tata));
    coada.push(1);
    viz[1]=1;
    int w;
    while(!coada.empty())
    {
        w=coada.front();
        coada.pop();
        p=v[w];
        while(p)
        {
            if(!viz[p->x] && flux[w][p->x]<capacitate[w][p->x])
            {
                viz[p->x]=1;
                tata[p->x]=w;
                coada.push(p->x);
            }
            p=p->urm;
        }
    }
    return viz[n];
}

int main()
{
    f>>n>>m;
    for(i=1;i<=m;i++)
    {
        f>>a>>b>>c;
        p=new nod;
        p->x = b;
        p->urm = v[a];
        v[a]=p;
        capacitate[a][b]=c;

        p=new nod;
        p->x=a;
        p->urm=v[b];
        v[b]=p;
    }
    while(bfs())
    {
        for(i=1;i<n;i++)
            if(tata[i]&& flux[i][n]<capacitate[i][n])
            {
                int minim=capacitate[i][n] - flux[i][n];
                j=i;
                while(tata[j]&&j!=1)
                {
                    minim= minimul(minim,capacitate[tata[j]][j] - flux[tata[j]][j]);
                    j=tata[j];
                }
                if(minim)
                {
                    flux[i][n]+=minim;
                    flux[n][i]-=minim;
                    j=i;
                    while(tata[j]&&j!=1)
                        flux[tata[j]][j] +=minim, flux[j][tata[j]]-=minim, j=tata[j];
                }
                fluxmaxim+=minim;
            }
    }
    g<<fluxmaxim<<'\n';
    f.close();
    g.close();
    return 0;
}