#include <iostream>
#include <vector>
#include <queue>
#include <fstream>

using namespace std;

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

typedef long long LL;
const int INF = 1e17;
const int dim = 10000;

struct Muchie {
    int pana, de;
    LL cap, f = 0;
    Muchie(int pana, int de, LL cap) : pana(pana), de(de), cap(cap) {}
};

vector<Muchie> g[dim];
int q[dim], dist[dim], poz[dim];
int nr_noduri, sursa, dest;
queue<int> coada;

void adaugaMuchie(int de_la, int pana, LL cap)
{
    g[de_la].push_back(Muchie(pana, (int)g[pana].size(), cap));
    g[pana].push_back(Muchie(de_la, (int)g[de_la].size() - 1, 0));
}

bool bfs()
{
    for (int i = 0; i < nr_noduri; ++i)
        dist[i] = -1;
    dist[sursa] = 0;

    /* de testat care e mai rapida!
    q[ 0 ] = sursa;
    for (int qh = 0, qt = 1; qh != qt; ++qh)
        {
            int v = q[qh];
            for (Muchie e : g[v])
                if (e.f < e.cap && dist[e.pana] == -1)
                    {
                        dist[e.pana] = dist[v] + 1;
                        q[qt++] = e.pana;
                    }
        }
    */
    coada.push(sursa);
    while (!coada.empty())
    {
        int v = coada.front();
        coada.pop();
        for (Muchie e : g[v])
            if (e.f < e.cap && dist[e.pana] == -1)
            {
                dist[e.pana] = dist[v] + 1;
                coada.push(e.pana);
            }
    }
    return dist[dest] != -1;
}

LL dfs(int v, LL flux)
{
    if (v == dest)
        return flux;
    for (int& i = poz[v]; i < (int)g[v].size(); ++i)
    {
        Muchie& e = g[v][i];
        if (e.f < e.cap && dist[e.pana] == dist[v] + 1)
        {
            LL df = dfs(e.pana, min(flux, e.cap - e.f));
            if (df > 0)
            {
                e.f += df;
                g[e.pana][e.de].f -= df;
                return df;
            }
        }
    }
    return 0;
}

LL maxFlow()
{
    LL flux = 0, df; /// df este valoarea cu care pot creste fluxul
    int i;
    while (bfs())
    {
        for (i = 0; i < nr_noduri; ++i)
            poz[i] = 0;
        while (df = dfs(sursa, INF))
            flux += df;
    }
    return flux;
}

int n, m, x;
int de_la[1005], pana[1005], cap[1005];

int main()
{
    int i;

    fin >> n >> m;

    nr_noduri = n;
    sursa = 0;
    dest = n - 1;

    for (i = 0; i < m; ++i) {
        fin >> de_la[i] >> pana[i] >> cap[i],
            --de_la[i],
            --pana[i];
        adaugaMuchie(de_la[i], pana[i], cap[i]);
    }
        


    fout << maxFlow() << "\n";



    return 0;
}