#include <fstream>
#include <vector>
#include <queue>
#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], Q[1001];
vector<int> V[1001];
bool used[1001];

int minim(int a, int b)
{
    if (a < b) return a;
    return b;
}

bool BFS()
{
    memset(used, false, sizeof(used));
    Q[0] = 1;
    Q[1] = 1;
    used[1] = true;

    for (int i = 1; i <= Q[0]; ++i)
    {
        int now = Q[i];
        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;
            Q[++Q[0]] = 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 = minim(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;
}