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

#define NMAX 1005
#define INF 0x3f3f3f3f

using namespace std;

int N, M, capacitate[NMAX][NMAX], flux[NMAX][NMAX], tata[NMAX];
bool used[NMAX];
vector <int> G[NMAX];

void citire()
{
    int x, y, z;

    scanf("%d %d", &N, &M);

    for (int i = 1; i <= M; ++i)
    {
        scanf("%d %d %d", &x, &y, &z);
        G[x].push_back(y);
        G[y].push_back(x);
        capacitate[x][y] = z;
    }
}

bool bfs(int nod)
{
    vector <int> :: iterator it;
    queue <int> q;
    int x;

    memset(used, false, sizeof(used));
    q.push(nod);
    used[nod] = true;

    while (q.empty() == false)
    {
        x = q.front();
        q.pop();
        if (x == N) continue;
        for (it = G[x].begin(); it != G[x].end(); ++it)
        {
            if (used[*it] == true || capacitate[x][*it] == flux[x][*it])
                continue;
            used[*it] = true;
            tata[*it] = x;
            q.push(*it);
        }
    }

    return used[N];
}

void fluxm()
{
    int fluxmin, fluxmax = 0;
    vector <int> :: iterator it;

    while (bfs(1))
    {
        for (it = G[N].begin(); it != G[N].end(); ++it)
        {
            if (capacitate[*it][N] == flux[*it][N] || !used[*it])
                continue;
            tata[N] = *it;
            fluxmin = INF;
            for (int nodc = N; nodc != 1; nodc = tata[nodc])
                fluxmin = min(fluxmin, capacitate[tata[nodc]][nodc] - flux[tata[nodc]][nodc]);
            for (int nodc = N; nodc != 1; nodc = tata[nodc])
            {
                flux[tata[nodc]][nodc] += fluxmin;
                flux[nodc][tata[nodc]] -= fluxmin;
            }
            fluxmax += fluxmin;
        }
    }

    printf("%d", fluxmax);
}

int main()
{
    freopen("maxflow.in", "r", stdin);
    freopen("maxflow.out", "w", stdout);

    citire();
    fluxm();

    return 0;
}