#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())
    {
        int minflux = infinit;
        for(int i = destinatie; i!=sursa; i=v[i])
            minflux=min(minflux, capacitate[v[i]][i] - flux[v[i]][i]);
        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;
}