#include <iostream>
#include <algorithm>
#include <fstream>
#include <vector>
#include <utility>
#include <queue>
#include <unordered_map>

const short magic = 1001;
std::vector<std::vector<int>> v(magic);
int capaci[magic][magic];

int bfsBottleneck(std::vector<std::vector<int>> &v, int n)
{
    std::queue<int> q;
    std::vector<int> generator(magic, 0);
    std::vector<bool> mark(magic, 0);
    q.push(1);
    mark[1] = true;

    while (!q.empty())
    {
        int nod = q.front();
        q.pop();
        if (nod == n) // aici o sa vedem din toate caile formate daca putem adauga flux ca sa nu refacem bfs-ul iar si iar;
        {
            int fluxTotal = 0;

            for (auto &&contestant : v[nod])
            {
                if (capaci[contestant][nod] == 0 or mark[contestant] == 0)
                    continue;

                int fluxx = capaci[contestant][nod];
                int checkFlux = contestant;
                while (checkFlux != 1)
                {
                    fluxx = std::min(fluxx, capaci[generator[checkFlux]][checkFlux]);
                    checkFlux = generator[checkFlux];
                }

                fluxTotal += fluxx;
                capaci[nod][contestant] += fluxx;
                capaci[contestant][nod] -= fluxx;
                checkFlux = contestant;
                while (checkFlux != 1)
                {
                    capaci[checkFlux][generator[checkFlux]] += fluxx;
                    capaci[generator[checkFlux]][checkFlux] -= fluxx;
                    checkFlux = generator[checkFlux];
                }
            }
            return fluxTotal;
        }

        for (auto &&vecin : v[nod])
        {
            if (capaci[nod][vecin] != 0 and mark[vecin] == 0)
            {
                mark[vecin] = 1;
                generator[vecin] = nod;
                q.push(vecin);
            }
        }
    }
    return -1;
}

int main()
{
    std::ifstream cin("maxflow.in");
    std::ofstream cout("maxflow.out");

    short n, m;
    cin >> n >> m;
    int x, y, cap;
    for (size_t i = 0; i < m; i++)
    {
        cin >> x >> y >> cap;
        v[x].push_back(y);
        v[y].push_back(x);
        capaci[x][y] = cap;
    }

    int fluxPlus, total = 0;
    while (1)
    {
        fluxPlus = bfsBottleneck(v, n);
        if (fluxPlus == -1)
        {
            break;
        }

        total += fluxPlus;
    }
    cout << total;
}