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

const int MAXN = 1005;
const int INF = 1 << 30;

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

vector<int> vecini[MAXN];
int capacitate[MAXN][MAXN];//Atentie! trebuie cu matrice de adiacenta deoarece avem nevoie in O(1) fluxul dintre oricare doua noduri
int flux[MAXN][MAXN];//Atentie! trebuie cu matrice de adiacenta deoarece avem nevoie in O(1) capacitatea dintre oricare doua noduri
int n;


void citire()
{
    int m;
    int a,b,c;
    in >> n >> m;
    for (int i = 1;i <= m;++i)
    {
        in >> a >> b >> c;

        vecini[a].push_back(b);
        capacitate[a][b] = c;
        vecini[b].push_back(a);
    }
}

bool vizitat[MAXN];
int tata[MAXN];

//intoarce adevarat daca s-a mai gasit un drum de ameliorare
bool BFS()//construieste arborele BFS
{
    for (int i = 1;i <= n;++i)
        vizitat[i] = false;
    int coada[MAXN] = {0};
    int p = 1,q = 1;
    coada[1] = 1;
    vizitat[1] = true;
    while (p <= q)
    {
        int nod = coada[p];
        ++p;
        if (nod == n)//arborele il construim fara destinatie
            continue;
        for (int i = 0;i < vecini[nod].size();++i)
        {
            int vecin = vecini[nod][i];
            if (vizitat[vecin] || flux[nod][vecin] == capacitate[nod][vecin])
                continue;
            coada[++q] = vecin;
            vizitat[vecin] = true;
            tata[vecin] = nod;
        }

    }

    return vizitat[n];
}

int main()
{
    citire();
    int fluxmaxim = 0;
    while(BFS())//cat timp mai am drum de ameliorare
        for (int i = 0;i < vecini[n].size();++i)
        {
            int vecin = vecini[n][i];
            if (!vizitat[vecin] || flux[vecin][n] == capacitate[vecin][n])
                continue;
            //influx -> fluxul minim care se adauga(sau daca e negativ, se scade) pe drumul de ameliorare
            int influx = INF;
            int nod = n;
            tata[n] = vecin;//legam temporar la frunza n pentru parcurgere
            while(nod != 1)//cautam minimul de influx
            {
                if (capacitate[tata[nod]][nod] - flux[tata[nod]][nod] < influx)
                    influx = capacitate[tata[nod]][nod] - flux[tata[nod]][nod];
                nod = tata[nod];
            }
            if (influx == 0)
                continue;
            nod = n;
            while(nod != 1)//adaugam influxul
            {
                flux[tata[nod]][nod] += influx;
                flux[nod][tata[nod]] -= influx;
                nod = tata[nod];
            }
            fluxmaxim += influx;
        }
    out << fluxmaxim << '\n';
    return 0;
}