#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1005;
const int SIZE = 100000;

#define fastcall __attribute__((optimize("-O3")))
#define inline __inline__ __attribute__((always_inline))

struct InParsare
{

    char buffer[SIZE];
    int index;
    inline fastcall char next_char()
    {
        if(index == SIZE)
        {
            fread(buffer,1,SIZE,stdin);
            index = 0;
            return next_char();
        }
        return buffer[index++];
    }
    InParsare()
    {
        freopen("maxflow.in","r",stdin);
        index = 0;
        fread(buffer,1,SIZE,stdin);
    }
    inline fastcall InParsare& operator >> (int &x)
    {
        x = 0;
        char c;
        for(c = next_char(); c < '0' || c > '9'; c = next_char());
        for(;c >= '0' && c <= '9'; c = next_char())
            x = x * 10 + c - '0';
        return *this;
    }
}in;

queue<int> coada;
vector<int> graf[MAXN];
int n, m, capacitate[MAXN][MAXN], flux[MAXN][MAXN];
int tata[MAXN];

int parcurgere()
{
    coada.push(1);

    tata[1] = 1;

    while(!coada.empty())
    {
        int nod = coada.front();
        coada.pop();
        if(nod != n)
        {
            for(int vecin : graf[nod])
            {
                if(!tata[vecin] && capacitate[nod][vecin] != flux[nod][vecin])
                {
                    tata[vecin] = nod;
                    coada.push(vecin);
                }
            }
        }
    }
    return tata[n];
}

int Flux;

void adauga(int nod)
{
    if(!tata[nod] || capacitate[nod][n] == flux[nod][n])
        return;

    int minim = capacitate[nod][n] - flux[nod][n];

    for(int i = nod; i != 1; i = tata[i])
        minim = min(minim, capacitate[tata[i]][i] - flux[tata[i]][i]);

    flux[nod][n] += minim;
    flux[n][nod] -= minim;

    Flux += minim;

    if(!minim) return;

    for(int i = nod; i != 1; i = tata[i])
    {
        flux[i][tata[i]] -= minim;
        flux[tata[i]][i] += minim;
    }
}

int main()
{
    freopen("maxflow.out","w",stdout);
    for([]()
    {
        in>>n>>m;
        for(int i = 1; i <= m; i++)
        {
            int a, b, cp;
            in>>a>>b>>cp;
            capacitate[a][b] = cp;
            graf[a].push_back(b);
            graf[b].push_back(a);
        }
    }(); parcurgere();)
    {
        for(int nod : graf[n])
            adauga(nod);

        memset(tata,0,sizeof(tata));
    }

    printf("%d\n",Flux);

    return 0;
}