#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#include <algorithm>
#include <climits>
#define DIM 1011
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");
int n,m,C[DIM][DIM],F[DIM][DIM];
int q[DIM],T[DIM],minim,sol;
bool viz[DIM];

vector<int> L[DIM];
vector<int>::iterator it;

bool bfs(){
    memset(viz,0,sizeof(viz));
    viz[1]=true;
    q[1]=1;
    int p=1,u=1;
    while(p<=u){
        int S=q[p];
        for(it=L[S].begin();it!=L[S].end();it++){
            if(!viz[*it] && C[S][*it]>F[S][*it]){
                q[++u]=*it;
                T[*it]=S;
                viz[*it]=true;
            }
        }
        p++;
    }
    return viz[n];
}

int main(void){
    register int i,j,x,y,c;

    f>>n>>m;
    for(i=1;i<=m;i++){
        f>>x>>y>>c;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y]=c;
    }

    while(bfs()){
        //am mai gasit un drum de la S la D
        for(it=L[n].begin();it!=L[n].end();it++){
            if(C[*it][n]>F[*it][n] && viz[*it]){
                int x=*it;
                minim=C[x][n]-F[x][n];
                while(T[x]){
                    minim=min(minim,C[T[x]][x]-F[T[x]][x]);
                    x=T[x];
                }
                x=*it;
                F[x][n]+=minim;
                F[n][x]-=minim;
                while(T[x]){
                    F[T[x]][x]+=minim;
                    F[x][T[x]]-=minim;
                    x=T[x];
                }
                sol+=minim;
            }
        }
    }

    g<<sol;
    return 0;
}