// Ford-Fulkerson - O(N*M^2) - MaxFlow
#include <fstream>
#include <vector>
#include <queue>
#define Nmax 1009
#define oo 2000000000
#define pb push_back
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");

int N,M,MaxFlow,Source,Sink,cap[Nmax][Nmax],flow[Nmax][Nmax],ante[Nmax],x,y,c;
vector < int > G[Nmax];
queue < int > Q;

int BFS()
{
     for(int i=1;i<=N;++i) ante[i]=0;
     ante[Source]=Source;
     for(Q.push(Source) ; !Q.empty() ; Q.pop())
     {
          int node=Q.front();
          if(node==Sink)continue;
          for(vector<int>::iterator it=G[node].begin();it!=G[node].end();++it)
               if(!ante[*it] && flow[node][*it]<cap[node][*it])
               {
                    ante[*it]=node;
                    Q.push(*it);
               }
     }
     return ante[Sink]!=0;
}

void FindFlow()
{
     for( ; BFS() ; )
          for(vector<int>::iterator it=G[Sink].begin(); it!=G[Sink].end();++it)
               if(ante[*it] && flow[*it][Sink]<cap[*it][Sink])
               {
                    ante[Sink]=*it;
                    int MinFlow=oo;
                    for(int i=Sink; i!=ante[i]; i=ante[i])
                         MinFlow=min(MinFlow,cap[ante[i]][i]-flow[ante[i]][i]);
                    if(MinFlow)
                    {
                        for(int i=Sink; i!=ante[i]; i=ante[i])
                        {
                             flow[ante[i]][i]+=MinFlow;
                             flow[i][ante[i]]-=MinFlow;
                        }
                        MaxFlow+=MinFlow;
                    }
               }
}

int main()
{
     f>>N>>M; Source=1; Sink=N;
     for(int i=1;i<=M;++i)
          f>>x>>y>>c , G[x].pb(y) , G[y].pb(x) , cap[x][y]+=c;
     FindFlow();
     g<<MaxFlow<<'\n';
     f.close();g.close();
     return 0;
}