#include <fstream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

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

const int INF = 0x3f3f3f3f;

int N, M;
int C[1005][1005], F[1005][1005], TT[1005];
vector<int> V[1005];
bool used[1005];

void bfs(int nod)
{
    if (nod == N)
        return;

    for (vector<int>::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
    {
        if (F[nod][*it] < C[nod][*it] && !used[*it])
        {
            used[*it] = true;
            TT[*it] = nod;
            bfs(*it);
        }
    }
}

int main()
{
    fin >> N >> M;
    for (int i = 1, nod1, nod2, cap; i <= M; ++i)
    {
        fin >> nod1 >> nod2 >> cap;

        V[nod1].push_back(nod2);
        V[nod2].push_back(nod1);
        C[nod1][nod2] = cap;
    }

    int flow = 0, fmin = INF;
    bool ok = true;
    while (ok)
    {
        memset(used, false, sizeof(used));
        used[1] = true;
        bfs(1);
        if (!used[N])
            break;

        for (vector<int>::iterator it = V[N].begin(); it != V[N].end(); ++it)
        {
            int nod = *it;
            if (!used[nod])
                continue;
            TT[N] = nod;

            fmin = INF;
            for (nod = N; nod != 1; nod = TT[nod])
                fmin = min(fmin, C[TT[nod]][nod] - F[TT[nod]][nod]);
            if (fmin == 0)
                continue;

            for (nod = N; nod != 1; nod = TT[nod])
            {
                F[TT[nod]][nod] += fmin;
                F[nod][TT[nod]] -= fmin;
            }

            flow += fmin;
        }
    }

    fout << flow << '\n';

    fin.close();
    fout.close();
    return 0;
}