#include <iostream>
#include <vector>
#include <queue>
#include <fstream>
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");


queue<int> coada;
vector<vector<int>> a;
vector<int> vizitat;
int c[1001][1001], flux[1001][1001], fmax, fmin = 999999999, n, m, tata[1001], ok;

void citire()
{
    f>>n>>m;

    int x, y, capacitate;

    a.resize(n+1);

    for(int i = 0; i < m; i++)
    {
        f>>x>>y>>capacitate;
        a[x].push_back(y);
        a[y].push_back(x);
        c[x][y] += capacitate;
    }

}

void afisare()
{
    for(int i = 1; i <= n; i++)
    {
        for(int j = 0; j < a[i].size(); j++)
        {
            g<<i<<" "<<a[i][j]<<" "<<c[i][a[i][j]]<<endl;
        }
    }
}

int bfs()
{
    coada.push(1);

    fill(vizitat.begin(), vizitat.end(), 0);

    vizitat[1] = 1;

    while(!coada.empty())
    {
        int nod = coada.front();
        coada.pop();

        if(nod != n)

        for(int k = 0; k < a[nod].size(); k++)
        {
            if(vizitat[a[nod][k]] == 0 && c[nod][a[nod][k]] != flux[nod][a[nod][k]])
            {
                coada.push(a[nod][k]);
                vizitat[a[nod][k]] = 1;
                tata[a[nod][k]] = nod;
            }
        }
    }

    return vizitat[n];
}

int main()
{
    citire();

    vizitat.resize(n+1);

    while(bfs())
        {

        for(int i = 0; i < a[n].size(); i++)
        {

            int nod = a[n][i];

            if(c[nod][n] != flux[nod][n] && vizitat[nod])
            {
                fmin = 999999999; tata[n] = nod;

                nod = n;

                while(nod != 1)
                {
                    if(fmin > c[tata[nod]][nod] - flux[tata[nod]][nod])
                        fmin = c[tata[nod]][nod] - flux[tata[nod]][nod];
                    nod = tata[nod];
                }

                if(fmin)
                {
                    nod = n;

                    while(nod != 1)
                    {
                        flux[tata[nod]][nod] += fmin;
                        flux[nod][tata[nod]] -= fmin;
                        nod = tata[nod];
                    }

                    fmax += fmin;
                }
            }
        }

        }
    g<<fmax;
}