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

ifstream cin ("maxflow.in");
ofstream cout ("maxflow.out");

struct Muchie { int nod_vecin , capacitate , urmatorul; } muchii[10001];
int numar_noduri , numar_muchii , capat[1001] , ramas[1001] , adancime[1001];

bool Breadth_First_Search ()
{
    for (int indice = 1 ; indice <= numar_noduri ; indice++)
        { adancime[indice] = 0; }

    queue <int> optiuni;
    for (optiuni.push(1) , adancime[1] = 1 ; !optiuni.empty() ; optiuni.pop())
    {
        const int nod_actual = optiuni.front();
        for (int indice = capat[nod_actual] ; indice ; indice = muchii[indice].urmatorul) {
            if (!adancime[muchii[indice].nod_vecin] && muchii[indice].capacitate) {
                adancime[muchii[indice].nod_vecin] = adancime[nod_actual] + 1;
                optiuni.push(muchii[indice].nod_vecin);
            }
        }
    } 

    return adancime[numar_noduri] != 0;
}

int Depth_First_Search (const int nod_actual , const int flux_actual)
{
    if (nod_actual == numar_noduri || !flux_actual)
        { return flux_actual; }

    for (int &indice = ramas[nod_actual] ; indice ; indice = muchii[indice].urmatorul) {
        if (adancime[muchii[indice].nod_vecin] == adancime[nod_actual] + 1 && muchii[indice].capacitate)
        {
            const int termen = Depth_First_Search(muchii[indice].nod_vecin , min(flux_actual , muchii[indice].capacitate));
            if (termen) {
                muchii[indice].capacitate -= termen;
                muchii[indice ^ 1].capacitate += termen;
                return termen;
            }
        }
    }

    return 0;
}

int main ()
{
    cin >> numar_noduri >> numar_muchii;

    for (int indice = 1 , nod_actual ; indice <= numar_muchii ; indice++)
    {
        cin >> nod_actual >> muchii[indice].nod_vecin >> muchii[indice].capacitate;
        muchii[indice].urmatorul = capat[nod_actual];
        capat[nod_actual] = indice;
        
        indice++; numar_muchii++;
        muchii[indice].nod_vecin = nod_actual;
        muchii[indice].urmatorul = capat[muchii[indice ^ 1].nod_vecin];
        capat[muchii[indice ^ 1].nod_vecin] = indice;
        muchii[indice].capacitate = 0;
    }

    int flux_maxim = 0;
    while (Breadth_First_Search()) 
    {
        for (int indice = 1 ; indice <= numar_noduri ; indice++)
            { ramas[indice] = capat[indice]; }

        while (int flux_actual = Depth_First_Search(1 , INT32_MAX))
            { flux_maxim += flux_actual; }
    }

    cout << flux_maxim;
    cout.close(); cin.close();
    return 0;
}