#include <fstream>
#include <vector>
#include <deque>
#include <bitset>
#define dim 1001
#define inf 1000000000
using namespace std;

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

int n,m,i,j,c[dim][dim],flux[dim][dim],t[dim],nod,vec,M,sol;
vector <int> l[dim];
bitset <dim> f;
deque <int> q;

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

    while(!q.empty()){
        nod=q.front();
        q.pop_front();

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

    return f[n];
}

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

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

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

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

                nod=l[nod][i];
                flux[nod][n]+=m;
                flux[n][nod]-=m;
                sol+=m;

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

    fout<<sol;

    return 0;
}