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

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

vector <int> adiacenta[1001];
int numar_noduri , capacitate[1001][1001] , flux[1001][1001] , nod_sursa[1001];
bool vizitat[1001];

bool Parcurgere ()
{
    for (int indice = 1 ; indice <= numar_noduri ; indice++)
        { vizitat[indice] = false; }

    queue <int> optiuni;
    vizitat[1] = true;
    optiuni.push(1);

    bool gasit = false;
    while (!optiuni.empty())
    {
        const int nod_actual = optiuni.front();
        for (auto nod_vecin : adiacenta[nod_actual]) {
            if (!vizitat[nod_vecin] && capacitate[nod_actual][nod_vecin] > flux[nod_actual][nod_vecin])
            {
                vizitat[nod_vecin] = true;
                gasit |= (nod_vecin == numar_noduri);
                nod_sursa[nod_vecin] = nod_actual;
                optiuni.push(nod_vecin);
            }
        }

        optiuni.pop();
    }

    return gasit;
}

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

    while (numar_arce--)
    { 
        int nod_1 , nod_2; 
        cin >> nod_1 >> nod_2 >> capacitate[nod_1][nod_2]; 
        adiacenta[nod_1].push_back(nod_2);
        adiacenta[nod_2].push_back(nod_1);
    }

    int flux_total = 0;
    while (Parcurgere())
    {
        for (auto nod_vecin : adiacenta[numar_noduri]) {
            if (vizitat[nod_vecin] && capacitate[nod_vecin][numar_noduri] > flux[nod_vecin][numar_noduri])
            {
                int adaos = (1LL << 31) - 1;
                nod_sursa[numar_noduri] = nod_vecin;
                for (int nod_actual = numar_noduri ; nod_actual != 1 ; nod_actual = nod_sursa[nod_actual])
                    { adaos = min(adaos , capacitate[nod_sursa[nod_actual]][nod_actual] - flux[nod_sursa[nod_actual]][nod_actual]); }

                for (int nod_actual = numar_noduri ; nod_actual != 1 ; nod_actual = nod_sursa[nod_actual])
                    { flux[nod_sursa[nod_actual]][nod_actual] += adaos; flux[nod_actual][nod_sursa[nod_actual]] -= adaos; }  

                flux_total += adaos; 
            }
        }
    }

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