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

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

int n;
vector < vector < int > > V;
int FMAX[1001][1001];
int F[1001][1001];
bool drum;
int Q[1001];
bool VIZ[1001];
int T[1001];

void citire()
{
    int m,i,x,y,f;
    fin>>n>>m;
    V.resize(n+1);
    for(i=1; i<=m; i++)
    {
        fin>>x>>y>>f;
        V[x].push_back(y);
        V[y].push_back(x);
        FMAX[x][y]=f;
    }
}

bool bfs()
{
    int k=1,i=1,nod1,nod2;
    Q[1]=1;
    vector < int >::iterator it;
    memset(VIZ,0,sizeof(VIZ));
    while(i<=k)
    {
        nod1=Q[i];
        for(it = V[nod1].begin(); it!=V[nod1].end(); it++)
        {
            nod2=*it;
            if(!VIZ[nod2] && F[nod1][nod2] < FMAX[nod1][nod2])
            {
                VIZ[nod2]=true;
                Q[++k]=nod2;
                T[nod2]=nod1;
            }
        }
        i++;
    }
    return VIZ[n];
}

int rezolvare()
{
    int nod,fmax, flux = 0;

    vector < int >::iterator i;
    while(bfs())
    {
        for(i=V[n].begin();i!=V[n].end();i++) {
            if(VIZ[*i] && F[*i][n]<FMAX[*i][n])
            {
                T[n]=*i;
                fmax = 2000000000;
                nod = n;
                while(nod != 1)
                {
                    fmax=min(fmax,FMAX[T[nod]][nod]-F[T[nod]][nod]);
                    nod=T[nod];
                }
                if(fmax != 0)
                {
                    nod = n;
                    while(nod != 1)
                    {
                        F[T[nod]][nod]+=fmax;
                        F[nod][T[nod]]-=fmax;
                        nod = T[nod];
                    }
                }
                flux += fmax;
            }

        }
    }

    return flux;
}

void afisare()
{
    int i,s=0;
    for(i=1; i<n; i++)
        s+=F[i][n];
    fout<<s;
}

int main()
{
    citire();
    fout << rezolvare();
    //afisare();
    return 0;
}