#include<fstream>
#include<queue>
#include<cstring>
using namespace std;

ifstream f("maxflow.in");
ofstream g("maxflow.out");

int n,m,j,i,s,a,b,c,viz[1005],z,tata[1005],cap[1005][1005],fluxmax,flux[1005][1005];

struct nod
{
    int x;
    //int y;
    nod *next;
}   *v[1005],*p;

queue<int> q;

int bf()
{
    memset(viz,0,sizeof(viz));
    memset(tata,0,sizeof(tata));

    q.push(1);
    viz[1]=1;

    while(!q.empty())
    {
        z=q.front();
        p=v[z];
        q.pop();

        while(p)
        {
            if(!viz[p->x]&&flux[z][p->x]<cap[z][p->x])
            {
                //cap[p->x]=(cap[z]+1)*(p->y);
                viz[p->x]=1;
                tata[p->x]=z;
                q.push(p->x);
            }
            p=p->next;
        }
    }
    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->y=c;
        cap[a][b]=c;
        p->next=v[a];
        v[a]=p;

        p=new nod;
        p->x=a;
        //p->y=0;
        //cap[b][a]=0;
        p->next=v[b];
        v[b]=p;
    }

    while(bf())
    {
        for(i=1;i<n;i++)
            if(tata[i]&&flux[i][n]<cap[i][n])
            {
                int minim=cap[i][n]-flux[i][n];
                for(j=i;j!=1;j=tata[j])
                    if(minim>cap[tata[j]][j]-flux[tata[j]][j])  minim=cap[tata[j]][j]-flux[tata[j]][j];
                if(minim)
                {
                    flux[i][n]+=minim;
                    flux[n][i]-=minim;
                    for(j=i;j!=1;j=tata[j])
                    {
                        flux[tata[j]][j]+=minim;
                        flux[j][tata[j]]-=minim;
                    }
                    fluxmax+=minim;
                }
            }
    }

    g<<fluxmax<<'\n';

    f.close();
    g.close();
    return 0;
}