#include<fstream>
#include<iostream>
#include<vector>
#include <cstring>
#define INF 0x3f3f3f3f
using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");



int n,m,k,i,j,p,x,y,t,cap,flux,fmin;
int C[1024][1024],F[1024][1024],coada[1024],viz[1024],precedent[1024];
///F[i][j] = fluxul curent dintre nodul i si j
///C[i][j] = capacitatea dintre nodul i si j


vector <int> v[1024];
vector <int> frunze;

bool bfs()
{
    int nod, i, vecin,dr,st;
    st=dr=1;
    coada[st] = 1;
    viz[1] = 1;
    for(i=2;i<=n;i++)
    {
        viz[i] = 0;
    }

    while(st <= dr)
    {
        nod = coada[st];
        for(i=0;i<v[nod].size();i++)
        {
            vecin = v[nod][i];
            if(viz[vecin] == 0 and C[nod][vecin] != F[nod][vecin]) //daca muchia nu este saturata
            {
                dr++;
                coada[dr] = vecin;
                viz[vecin] = 1;
                precedent[vecin] = nod;
                if(vecin == n)
                    return true;
            }
        }
        st++;
    }
    return false;

}

int main()
{
    fin >> n >> m;
    for(i=1;i<=m;i++)
    {
        fin>>x>>y>>cap;
        C[x][y] += cap;
        v[x].push_back(y);
        v[y].push_back(x);
        if(y == n)
        {
            frunze.push_back(x);
        }

    }
    flux = 0;
    ///cand nu mai gasim drum de la sursa la destinatie inseamna ca fluxul este maxim
    while(bfs() == true)
    //bfs();
    {
        for(j = 0; j < frunze.size(); j++)
        {
            int nod = frunze[j];
            if(C[nod][n] != F[nod][n])
            {
                precedent[n] = nod;
                //fout << nod << "\n";
                fmin = INF;
                nod = n;
                //fmin = min(fmin, C[nod][n] - F[nod][n]);
                while(nod != 1)
                {
                    fmin = min(fmin, C[precedent[nod]][nod] - F[precedent[nod]][nod]);
                    nod = precedent[nod];
                }
                nod = n;
                while(nod != 1)
                {
                    F[precedent[nod]][nod] += fmin;
                    F[nod][precedent[nod]] -= fmin;
                    nod = precedent[nod];
                }
                flux = flux + fmin;



            }

        }
        /*fmin = INF;
        int nod = n;
        ///selectam cantitatea minima de flux disponibila de pe augmenting path-ul gasit
        while(nod != 1)
        {
            fmin = min(fmin, C[precedent[nod]][nod] - F[precedent[nod]][nod]);
            nod = precedent[nod];
        }
        nod = n;
        ///updatam cantitatea de flux de pe drumul parcurs
        while(nod != 1)
        {
            F[precedent[nod]][nod] += fmin;
            F[nod][precedent[nod]] -= fmin;
            nod = precedent[nod];
        }
        flux = flux + fmin;
        */
    }
    fout << flux << "\n";
}