#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
#define inf 0x3f3f3f3f
using namespace std;

ofstream fout ("maxflow.out");
int n, m, C[1010][1010], F[1010][1010], T[1010], viz[1010];
vector <int> G[10100], G1[1010];

void citire()
{
    ifstream fin ("maxflow.in");
    fin >> n >> m;
    int x, y, z;
    while(m--)
    {
        fin >> x >> y >> z;
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y]=z;
    }
    fin.close();
}

int BFS()
{
    queue <int> q;
    fill(viz, viz+n+1, 0);
    fill(T, T+n+1, 0);
    int nod=1, v;
    q.push(1);
    viz[nod]=1;
    T[nod]=0;
    while(!q.empty())
    {
        nod=q.front();
        q.pop();
        if(nod==n)
            return 1;
        for(unsigned int i=0;i<G[nod].size();i++)
        {
            v=G[nod][i];
            if(C[nod][v]-F[nod][v]>0 && viz[v]==0)
            {
                q.push(v);
                viz[v]=1;
                T[v]=nod;
            }
        }
        for(unsigned int i=0; i<G1[nod].size();i++)
        {
            v=G1[nod][i];
            if(F[v][nod]>0 && viz[v]==0)
            {
                q.push(v);
                T[v]=nod;
                viz[v]=1;
            }
        }
    }
    return 0;
}

int main()
{
    citire();
    int fmin, maxflow=0;
    while(BFS())
    {
        fmin=inf;
        for(int x=n; T[x]!=0; x=T[x])
        {
            fmin=min(fmin, C[T[x]][x]-F[T[x]][x]);
        }
        for(int x=n; T[x]!=0; x=T[x])
        {
            F[T[x]][x]+=fmin;
            F[x][T[x]]-=fmin;
        }
        maxflow+=fmin;
    }
    fout << maxflow;
    return 0;
}