#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;

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

vector<int> v[1001];
vector<int> dest;
int c[1001][1001],f[1001][1001],n,m,t[1001],flux;
bool visited[1001];
queue<int> q;

void solve()
{
    int fmin = 9999999999;
    for(int i=n;i!=1;i = t[i])
    {
        fmin = min(fmin,c[t[i]][i] - f[t[i]][i]);
    }
    if(fmin==0)
        return;
    for(int i=n;i!=1;i = t[i])
    {
        f[t[i]][i] += fmin;
        f[i][t[i]] -= fmin;
    }
    flux += fmin;
}


bool BFS()
{

    for(int i=1;i<=n;i++)
        visited[i] = false;

    q.push(1);
    visited[1] = true;
    while(!q.empty())
    {
        int x = q.front();
        q.pop();

        if(x==n)
          continue;
        for(unsigned int i=0;i<v[x].size();i++)
        {
            if(visited[v[x][i]])
                continue;
            if( c[x][v[x][i]] > f[x][v[x][i]] )
            {
                q.push(v[x][i]);
                visited[v[x][i]] = true;
                t[v[x][i]] = x;
            }
        }
    }
    return visited[n];
}


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

    while(BFS())
    {
        for(unsigned int i=0;i<v[n].size();i++)
        {
            t[n] = v[n][i];
            if(!visited[t[n]])
                continue;
            if(c[t[n]][n] > f[t[n]][n])
                solve();
        }
    }

    fout<<flux<<'\n';
    fin.close();
    fout.close();
    return 0;
}