#include <iostream>
#include <fstream>
#include <vector>
#define MAX 1001
#include <climits>
#define INF INT_MAX

using namespace std;

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

vector < int > v[MAX];

int viz[MAX], T[MAX], flow, f[MAX][MAX], c[MAX][MAX], n, m, cd[MAX];

void read()
    {
        int x, y, cant;
        fi>>n>>m;
        for(int i=1; i<=m; i++)
        {
            fi>>x>>y>>cant;
            c[x][y]=c[y][x]=cant;
            v[x].push_back(y);
            v[y].push_back(x);
        }
    }

void rein()
    {
        for(int i=1; i<=n; i++)
            viz[i]=0;
    }

int exista_drum()
    {
        rein();
        viz[1]=1;
        cd[0]=cd[1]=1;
        for(int i=1; i<=cd[0]; i++)
        {
            int node = cd[i];
            for(size_t j=0; j<v[node].size(); j++)
            {
                int w = v[node][j];
                if(c[node][w]==f[node][w] || viz[w]==1)
                    continue;
                viz[w]=1;
                cd[0]++;
                T[w]=node;
                cd[cd[0]] = w;
            }
        }
        return viz[n];
    }

void det_flux()
    {
        while(exista_drum())
        {int node = n;
        for(size_t i=0; i<v[n].size(); i++)
        {
            int nod_actual = v[node][i];
            if(viz[nod_actual]==0 || f[node][nod_actual]==c[node][nod_actual])
                continue;
            T[node] = nod_actual;
            int cant = INF;
            for(int j=n; j!=1; j=T[j])
                cant = min(cant, c[T[j]][j] - f[T[j]][j]);
            if(cant!=0)
            {
                flow+=cant;
                for(int j=n; j!=1; j=T[j])
                    {
                        f[T[j]][j]+=cant;
                        f[j][T[j]]-=cant;
                    }
            }
        }
        }
    }

int main()
{
    read();
    det_flux();
    g<<flow;

    return 0;
}