#include <fstream>
#include <vector>
#include <deque>
#include <bitset>
using namespace std;

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

int n,i,j,k,m,nod,vec,sol,minim,c[1001][1001],flux[1001][1001],t[1001];
vector <int> l[1001];
bitset <1001> f;
deque <int> d;

bool bfs(){
    f.reset();
    d.push_back(1);
    f[1]=1;

    while(!d.empty()){
        nod=d.front();
        for(i=0;i<l[nod].size();i++){
            vec=l[nod][i];
            if(!f[vec] && c[nod][vec]-flux[nod][vec]>0){
                f[vec]=1;
                t[vec]=nod;
                d.push_back(vec);
            }
        }

        d.pop_front();
    }

    return f[n];
}

int main(){
    fin>>n>>m;
    for(;m;m--){
        fin>>i>>j>>k;
        l[i].push_back(j);
        l[j].push_back(i);
        c[i][j]=k;
    }

    while(bfs()){
        for(i=0;i<l[n].size();i++){
            ///nod=n;
            ///minim=200000000;
            nod=l[n][i];

            if(f[nod] && c[nod][n]-flux[nod][n]>0){
                minim=c[nod][n]-flux[nod][n];

                while(nod!=1){
                    minim=min(minim,c[t[nod]][nod]-flux[t[nod]][nod]);
                    nod=t[nod];
                }

                nod=l[n][i];
                flux[nod][n]+=minim;
                flux[n][nod]-=minim;

                while(nod!=1){
                    flux[t[nod]][nod]+=minim;
                    flux[nod][t[nod]]-=minim;
                    nod=t[nod];
                }

                sol+=minim;

            }
        }
    }

    fout<<sol;

    return 0;
}