#include <fstream>
#include <vector>
#include <cstring>
#include <queue>

using namespace std;

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

const int maxN=1024, infinit=0x3f3f3f3f;
vector <int> G[maxN];
int capacitate[maxN][maxN], flux[maxN][maxN], v[maxN];
int nr_noduri, nr_muchii, sursa, destinatie, maxflux;
bool traseu[maxN];
queue <int> q;

bool bfs()
{
    memset(traseu, 0, sizeof(traseu));
    q.push(sursa);
    while(!q.empty())
    {
        int poz=q.front(), vecin;
        q.pop();
        if(poz==destinatie)
            continue;
        for(int i=0; i<G[poz].size(); i++)
        {
            vecin=G[poz][i];
            if(capacitate[poz][vecin]==flux[poz][vecin])
                continue;
            if(traseu[vecin])
                continue;
            traseu[vecin]=true;
            v[vecin]=poz;
            q.push(vecin);
        }
    }
    return traseu[destinatie];
}

void citire()
{
    fin>>nr_noduri>>nr_muchii;
    for(int i=1; i<=nr_muchii; i++)
    {
        int a, b, c;
        fin>>a>>b>>c;
        capacitate[a][b]=c;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    sursa=1;
    destinatie=nr_noduri;
}

void solve()
{
    while(bfs())
    {
        for(int j=0; j<G[destinatie].size(); j++)
        {
            int nod=G[destinatie][j];
            if(flux[nod][destinatie] == capacitate[nod][destinatie])
                continue;
            if(!traseu[nod])
                continue;
            v[destinatie]=nod;

            int minflux=infinit;
            for(int i=destinatie; i!=sursa; i=v[i])
                minflux=min(minflux, capacitate[v[i]][i] - flux[v[i]][i]);
            if(minflux==0)
                continue;
            for(int i=destinatie; i!=sursa; i=v[i])
            {
                flux[v[i]][i]+=minflux;
                flux[i][v[i]]-=minflux;
            }
            maxflux+=minflux;
        }
    }
    fout<<maxflux;
}


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