#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];
queue<int> Q;
bool used[1005];

bool bfs()
{
    memset(used, false, sizeof(used));

    Q.push(1);
    used[1] = true;

    while (!Q.empty())
    {
        int now = Q.front();
        Q.pop();

        if (now == N)
            continue;

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

    return used[N];
}

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;
    while (bfs())
    {
        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;
}