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

using namespace std;

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

const int maxN = 1005, inf = 0x3f3f3f3f;
int cap[maxN][maxN], flux[maxN][maxN], p[maxN];
int n, m, max_flux;
vector <int> G[maxN];
bool viz[maxN];

bool bfs(int s, int d)
{
    memset(viz, 0, sizeof viz);
    queue <int> q;
    q.push(s);
    while(!q.empty())
    {
        int poz = q.front();
        q.pop();
        if(viz[poz])
            continue;
        viz[poz] = 1;
        for(auto vecin : G[poz])
        {
            if(!viz[vecin] && cap[poz][vecin] > flux[poz][vecin])
            {
                p[vecin] = poz;
                if(vecin == d)
                    return 1;
                q.push(vecin);
            }
        }
    }
    return 0;
}

int main()
{
    fin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int a, b, c;
        fin >> a >> b >> c;
        cap[a][b] = c;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    while(bfs(1, n))
    {
        for(int vecin : G[n])
        {
            if(flux[vecin][n] == cap[vecin][n])
                continue;
            if(!viz[vecin])
                continue;
            p[n] = vecin;
            int min_flux = inf;
            for(int x = n; x != 1; x = p[x])
                min_flux = min(min_flux, cap[p[x]][x] - flux[p[x]][x]);
            if(min_flux == 0)
                continue;
            for(int x = n; x != 1; x = p[x])
            {
                flux[p[x]][x] += min_flux;
                flux[x][p[x]] -= min_flux;
            }
            max_flux += min_flux;
        }
    }
    fout << max_flux;
    return 0;
}