#include<fstream>
#include<vector>
#include<bitset>
#include<deque>
#define inf 2000000000
using namespace std;
vector <int> L[1003];
bitset<1003> u;
deque <int> q;
int T[1003], n, m, nod, i, x, y, z, C[1003][1003], F[1003][1003], minim, flux;
int bfs()
{
    int gasit=0;
    u.reset();
    //q.clear();
    q.push_back(1);
    u[1]=1;
    while(!q.empty()){
        nod=q.front();
        for(int i=0; i<L[nod].size(); i++)
        {
            int fiu=L[nod][i];
            if(u[fiu]==0 && C[nod][fiu]>F[nod][fiu]){
                q.push_back(fiu);
                u[fiu]=1;
                T[fiu]=nod;
                if(fiu==n){
                    gasit=1;
                }
            }
        }
        q.pop_front();
    }
    return gasit;
}
ifstream in("maxflow.in");
ofstream out("maxflow.out");
int main()
{
    in>>n>>m;
    for(i=1; i<=m; i++)
    {
        in>>x>>y>>z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y]=z;
    }
    while(bfs())
    {
        for(i=0; i<L[n].size(); i++)
        {
            nod=L[n][i];
            if(u[nod]==1 && C[nod][n]>F[nod][n])
            {
                minim=C[nod][n]-F[nod][n];
                for(nod=L[n][i]; T[nod]!=0 && minim!=0; nod=T[nod])
                {
                    minim=min(minim, C[T[nod]][nod]-F[T[nod]][nod]);
                }
                if(minim!=0)
                {
                    flux+=minim;
                    nod=L[n][i];
                    F[nod][n]+=minim;
                    F[n][nod]-=minim;
                    for(nod=L[n][i]; T[nod]!=0; nod=T[nod])
                    {
                        F[T[nod]][nod]+=minim;
                        F[nod][T[nod]]-=minim;
                    }
                }
            }
        }
        for(i=1; i<=n; i++)
            T[i]=0;
    }
    out<<flux;
    return 0;
}