#include <fstream>
#include <vector>
#include <stack>
#include <cstring>

using namespace std;

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

const int INF = 0x3f3f3f3f;

int N, M;
int flow, fmin;
int C[1001][1001], F[1001][1001], TT[1001];
vector<int> V[1001];
stack<int> ST;
bool used[1001];

bool BFS()
{
    memset(used, false, sizeof(used));
    ST.push(1);
    used[1] = true;

    while (!ST.empty())
    {
        int now = ST.top();
        ST.pop();
        if (now == N)
            continue;
        for (int i = 0; i <= V[now].size() - 1; ++i)
        {
            int nod = V[now][i];
            if (C[now][nod] == F[now][nod] || used[nod])
                continue;
            ST.push(nod);
            used[nod] = true;
            TT[nod] = now;
        }
    }

    return used[N];
}

int main()
{
    fin >> N >> M;
    for (int i = 1, nod1, nod2, flux; i <= M; ++i)
    {
        fin >> nod1 >> nod2 >> flux;
        C[nod1][nod2] += flux;
        V[nod1].push_back(nod2);
        V[nod2].push_back(nod1);
    }

    for (flow = 0; BFS();)
        for (int i = 0; i <= V[N].size() - 1; ++i)
        {
            int nod = V[N][i];
            if (F[nod][N] == C[nod][N] || !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;
}