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

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

vector<int> graf[1005];
queue<int> coada;
int N, M, capacitate[1005][1005], flux[1005][1005], tata_de[1005];

bool BFS()
{
    memset(tata_de, 0, sizeof tata_de);
    coada.push(1);
    tata_de[1] = 1;
    while (!coada.empty())
    {
        int curent = coada.front();
        // Exista drum cu capacitate > 0 pana la N
        coada.pop();
        for (int i = 0; i < graf[curent].size(); i++)
        {
            int vecin = graf[curent][i];
            // Vecin nevizitat si mai putem transporta apa prin conducta
            if (tata_de[vecin] == 0 && capacitate[curent][vecin] > flux[curent][vecin])
            {
                tata_de[vecin] = curent;
                coada.push(vecin);
            }
        }
    }
    return tata_de[N] != 0;
}

int main()
{
    fin >> N >> M;
    for (int i = 0 ; i < M; i++)
    {
        int x,y,c;
        fin >> x >> y >> c;
        graf[x].push_back(y);
        graf[y].push_back(x);
        capacitate[x][y] = c;
    }
    int max_flow = 0;
    while (BFS())
    {
        // Optimizare: Economisim BFS-uri prin ideea ca obtinem mai multe trasee dintr-un singur BFS daca plecam din tatii finalului
        for (int i = 0; i < graf[N].size(); i++)
        {
            int fluxMin = INT32_MAX, vecin = graf[N][i];
            // ATENTIE! Exista posibilitatea de a exista muchie directa intre nodul de inceput si cel de sfarsit,
            // caz in care mai trebuie adaugata o conditie la if-ul de continuare (tatal nodului de start e mereu 0!)

            // Daca vecinul nu are tata sau nu mai are capacitate de a transporta apa, nu-l luam in considerare
            if (tata_de[vecin] == 0 || capacitate[tata_de[vecin]][vecin] - flux[tata_de[vecin]][vecin] <= 0)
                continue;
            fluxMin = capacitate[tata_de[vecin]][vecin] - flux[tata_de[vecin]][vecin];
            while (vecin != 1)
            {
                fluxMin = min(fluxMin, capacitate[tata_de[vecin]][vecin] - flux[tata_de[vecin]][vecin]);
                vecin = tata_de[vecin];
            }
            vecin = graf[N][i];
            while (vecin != 1)
            {
                flux[tata_de[vecin]][vecin] += fluxMin;
                flux[vecin][tata_de[vecin]] -= fluxMin;
                vecin = tata_de[vecin];
            }
            max_flow += fluxMin;
        }
    }
    fout << max_flow << "\n";
    return 0;
}