/*#include <fstream>

using namespace std;

ifstream f ("maxflow.in");
ofstream g ("maxflow.out");

int cap[1005][1005], s, t, F = 0, n, m, flux[1005][1005], q[1005], tata_mare[1005], p, u;
bool viz[1005];

struct nod
{
    int info;
    nod *adr;
} *v[1005], *pq, *uq;

void adauga (int x, int y)
{
    nod *c;
    c = new nod;

    c -> info = y;
    c -> adr = v[x];
    v[x] = c;
}

void citire ()
{
    f >> n >> m;

    int x, y, c;

    for (int i = 1; i <= m; i ++)
    {
        f >> x >> y >> c;

        adauga (x, y);
        adauga (y, x);
        cap[x][y] = c;
    }
}

bool bfs ()
{
    for (int i = 1; i <= n; i ++)
        viz[i] = 0;

    int curent;

    p = u = 1;
    q[u] = s;
    viz[s] = 1;

    nod *c;

    while (p <= u)
    {
        curent = q[p];
         ++ p;

        if (curent != t)

        {c = v[curent];

        while (c)
            {
                if (cap[curent][c -> info] > flux[curent][c -> info] && !viz[c -> info])
                    {
                        ++ u;
                        q[u] = c -> info;
                        tata_mare[c -> info] = curent;
                        viz[c -> info] = 1;
                    }

            c = c -> adr;
            }
        }

    }

    g << "lel" << " ";

    return viz[t];
}

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

int main()
{
    citire ();
    s = 1;
    t = n;

    int curent, minim, inapoi;
    nod *c;

    while (bfs ())
    {
        c = v[t];
        while (c)
        {
            curent = c -> info;

            tata_mare[t] = curent;

            minim = (1 << 31) - 1;

            inapoi = t;

            while (inapoi != s)
            {
                minim = mini (minim, cap[tata_mare[inapoi]][inapoi] - flux[tata_mare[inapoi]][inapoi]);
                inapoi = tata_mare[inapoi];
            }

            inapoi = t;

            while (inapoi != s)
                {
                    flux[tata_mare[inapoi]][inapoi] += minim;
                    flux[inapoi][tata_mare[inapoi]] -= minim;
                    inapoi = tata_mare[inapoi];
                }

                 F += minim;

            c = c -> adr;
        }
    }

    g << F;

    f.close ();
    g.close ();
    return 0;
}*/

#include <stdio.h>
#include <vector>

using namespace std;

#define NMAX 1024
#define pb push_back
#define sz size()
#define mp make_pair
#define INF 0x3f3f3f3f

int C[NMAX][NMAX];
int F[NMAX][NMAX];
int TT[NMAX];
vector<int> G[NMAX];
int N, M;
int cd[NMAX];
int viz[NMAX];

int BF()
{
    int i, j, nod, V;

    cd[0] = 1;
    cd[1] = 1;
    for(int i = 1; i <= sizeof(viz); i ++)
        viz[i] = 0;

    viz[1] = 1;

    for (i = 1; i <= cd[0]; i++)
    {
        nod = cd[i];
                if (nod == N) continue;
        for (j = 0; j < G[nod].sz; j++)
            {
                V = G[nod][j];
                if (C[nod][V] == F[nod][V] || viz[V]) continue;
                viz[V] = 1;
                cd[ ++cd[0] ] = V;
                TT[V] = nod;
            }
    }

    return viz[N];
}

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

    int i, flow, fmin, x, y, z, nod;

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

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

    for (flow = 0; BF();)
        for (i = 0; i < G[N].sz; i++)
        {
            nod = G[N][i];
            if (F[nod][N] == C[nod][N] || !viz[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;
        }

    printf("%d ", flow);
    return 0;
}