#include <fstream>
#include <algorithm>
#include <vector>
#include <deque>
using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

int n, m, nr, minim, sol, x, y, k, f[1010], t[1010], capacitate[1010][1010], flux[1010][1010];
deque <int> c;
vector <int> a[1010];

int bfs(){
    /// initializam vectorul de frecventa
    for(int i=1; i<=1000; i++){
        f[i]=0;
    }
    c.push_back(1);
    f[1]=1;
    /// 1 este sursa, n destinatia
    while(!c.empty()){
        int nod1=c.front();
        c.pop_front();
        for(int i=0; i<a[nod1].size(); i++){
            int nod2=a[nod1][i];
            if(f[nod2]==0 && capacitate[nod1][nod2]>flux[nod1][nod2]){
                c.push_back(nod2);
                t[nod2]=nod1;
                f[nod2]=1;
            }
        }
    }
    /// verific daca s-a ajuns in n
    if(f[n]==1){
        return 1;
    }else{
        return 0;
    }
}

int main(){
    fin>>n>>m;
    for(int i=1; i<=m; i++){
        fin>>x>>y>>k;
        a[x].push_back(y);
        a[y].push_back(x);
        capacitate[x][y]=k;
    }
    while(bfs()){
        /// vedem de unde se poate ajunge in n
        for(int i=0; i<a[n].size(); i++){
            int nod=a[n][i];
            if(capacitate[nod][n]>flux[nod][n] && f[nod]==1){
                /// in minim vad cu cat pot mari fluxul
                minim=capacitate[nod][n]-flux[nod][n];
                nr=nod;
                while(t[nr]){
                    minim=min(minim, capacitate[ t[nr] ][nr]-flux[ t[nr] ][nr]);
                    nr=t[nr];
                }
                sol+=minim;
                flux[nod][n]+=minim;
                flux[n][nod]-=minim;
                nr=nod;
                while(t[nr]){
                    flux[ t[nr] ][nr]+=minim;
                    flux[nr][ t[nr] ]-=minim;
                    nr=t[nr];
                }
            }
        }
    }
    fout<<sol;
}