# include <fstream>
 # include <algorithm>
 # include <vector>
 # include <cstring>
 # include <queue>
 # define NR 1005
 # define inf 999999999
 using namespace std;
 ifstream f("maxflow.in");
 ofstream g("maxflow.out");
 vector <int> v[NR];
 queue <int> q;

 int i,j,n,m,x,y,S,D,flux,minn;
 int c[NR][NR], F[NR][NR], T[NR];


 bool bfs ()
 {
     int i,j,k,urm,ok=0;
     memset (T, 0, sizeof(T));

     T[S]=-1; q.push(S);
     while (! q.empty())
     {
         k=q.front(); q.pop();
         for (i=0; i<v[k].size(); ++i)
         {
             urm=v[k][i];
             if (T[urm]==0 && c[k][urm]>F[k][urm])
             {
                 if (urm==D) ok=1;
                 else {
                          T[urm]=k;
                          q.push(urm);
                      }
             }
         }
     }
     return ok;
 }
 int main ()
 {
    f>>n>>m;
    for (i=1; i<=m; ++i)
    {
        f>>x>>y; f>>c[x][y];
        v[x].push_back(y);
        v[y].push_back(x);
    }

    S=1; D=n;

    //dinic
    while(bfs())
    {
        for (i=0; i<v[D].size(); ++i)
        {
            int ant=v[D][i];
            if (T[ant]!=0 && c[ant][D]>F[ant][D])
            {
                T[D]=ant; minn=inf;
                for (int nod=D; nod!=S; nod=T[nod])
                    minn=min (minn, c[T[nod]][nod] - F[T[nod]][nod]);

                if (minn<=0) continue;

                flux+=minn;

                for (int nod=D; nod!=S; nod=T[nod])
                {
                    F[T[nod]][nod]+=minn;
                    F[nod][T[nod]]-=minn;
                }
            }
        }
    }

    g<<flux<<"\n";

    return 0;
 }