#include <bits/stdc++.h>
#define NMAX 1008

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

int n, m;
int s, t;
int c[NMAX][NMAX], f[NMAX][NMAX], tata[NMAX];
vector <int> G[NMAX];

void citire();
bool BFS();
void rezolvare();

int main()
{
    citire();
    rezolvare();
    return 0;
}

void citire()
{
    int x, y, z;
    fin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        fin >> x >> y >> z;
        c[x][y] = z;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    s = 1;
    t = n;
}

bool BFS()
{
    for (int i = 1; i <= n; i++)
        tata[i] = -1;
    tata[s] = 0;

    queue <int> Q;
    Q.push(1);
    while (!Q.empty())
    {
        int nod = Q.front();
        Q.pop();

        if (nod == n)
            continue;

        for (int i = 0; i < G[nod].size(); i++)
        {
            int vf = G[nod][i];

            if (tata[vf] == -1 && f[nod][vf] < c[nod][vf])
            {
                tata[vf] = nod;
                Q.push(vf);
            }
        }
    }
    if (tata[t] < 0)
        return 0;
    return 1;
}

void rezolvare()
{
    int max_flow = 0;
    while (BFS())
    {
        for (int i = 0; i < G[t].size(); i++)
        {
            int nod = G[t][i];
            if (f[nod][t] == c[nod][t] || tata[nod] == -1)
                continue;
            tata[t] = nod;

            int minim = 1e9;
            for (int j = t; j != 1; j = tata[j])
                minim = min(minim, c[tata[j]][j] - f[tata[j]][j]);
            for (int j = t; j != 1; j = tata[j])
            {
                f[tata[j]][j] += minim;
                f[j][tata[j]] -= minim;
            }
            max_flow += minim;
        }
    }

    fout << max_flow;
}