#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
using namespace std;

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

int n,m,x,y,c;
struct muchii
{
    int nod1,nod2,cap,flux;
}v[10001];
bool viz[1001];
vector<int>g[1001];
queue<int>q;
int tata[1001], sol;

bool bfs()
{
    memset ( viz, 0, sizeof ( viz ) );
    q.push(1);
    while(!q.empty())
    {
        int nod=q.front();
        q.pop();

        for(int i=0;i<g[nod].size();i++)
        {
            int nou = v[g[nod][i]].nod2;
            int cap = v[g[nod][i]].cap;
            int flux = v[g[nod][i]].flux;
            if ( viz[nou] == 0 && cap - flux > 0){
                viz[nou] = 1;
                tata[nou] = g[nod][i];
                q.push ( nou );
            }
        }
    }
    if ( viz[n] == 0 )
        return 0;
    return 1;
}
int main()
{
    fin>>n>>m;
    for(int i=1;i<=2*m;i+=2)
    {
        fin>>x>>y>>c;
        g[x].push_back(i);
        g[y].push_back(i+1);
        v[i]={x,y,c,0};
        v[i+1]={y,x,0,0};
    }
    while( bfs ( ) == 1 ){
        int siz = g[n].size ( );
        for ( int i = 0; i < siz; i++ ){
            int a = g[n][i] + 1;
            if ( g[n][i] % 2 == 0 )
                a = g[n][i] - 1;
            int nou=v[a].nod1;
            int cap=v[a].cap;
            int flux=v[a].flux;
            if(cap>flux && viz[nou] == 1 )
            {
                int Min=cap-flux;
                int x=nou;
                while(x!=1)
                {
                    Min=min(Min,v[tata[x]].cap-v[tata[x]].flux);
                    x=v[tata[x]].nod1;
                }
                x=nou;
                sol+=Min;
                v[g[n][i]].flux-=Min;
                if(g[n][i]%2==0)
                    v[g[n][i]-1].flux+=Min;
                else
                    v[g[n][i]+1].flux+=Min;
                while(x!=1)
                {
                    v[tata[x]].flux+=Min;
                    if(tata[x]%2==0)
                        v[tata[x]-1].flux-=Min;
                    else
                        v[tata[x]+1].flux-=Min;
                    x=v[tata[x]].nod1;
                }
            }
        }
    }
    fout<<sol;
    return 0;
}