#include <bits/stdc++.h>

using namespace std;
const int VMAX = 1e3;
const int EMAX = 5e3;
const int NONE = -1;
const int INF = 2e9;

struct MaxFlow {
   int flow[1 + VMAX][1 + VMAX], cap[1 + VMAX][1 + VMAX];
   vector<int> network[1 + VMAX]; bool vis[1 + VMAX];
   int prev[1 + VMAX];

   int source, sink;

   void add_edge ( int u, int v, int t ) {
      network[u].push_back ( v );
      network[v].push_back ( u );
      cap[u][v] = t;
   }

   bool bfs () {
       for ( int node = 1; node <= VMAX; node ++ )
          vis[node] = false;
       for ( int node = 1; node <= VMAX; node ++ )
          prev[node] = NONE;

       queue<int> q; q.push ( source );
       vis[source] = true;
       while ( !q.empty () ) {
          int node = q.front (); q.pop ();
          for ( int negr : network[node] ) {
             if ( !vis[negr] && flow[node][negr] < cap[node][negr] ) {
               prev[negr] = node;
               if ( negr == sink )
                 return true;
               q.push ( negr );
               vis[negr] = true;
             }
          }
       }
       return false;
   }

   int solve () {

      int maxFlow = 0;
      while ( bfs () ) {
         for ( int negr : network[sink] ) {
            if ( vis[negr] && flow[negr][sink] < cap[negr][sink] ) {
              prev[sink] = negr;

              int node = sink; int addFlow = INF;
              while ( node != source ) {
                 addFlow = min ( addFlow, cap[prev[node]][node] - flow[prev[node]][node] );
                 node = prev[node];
              }

              maxFlow += addFlow;

              node = sink;
              while ( node != source ) {
                 flow[prev[node]][node] += addFlow;
                 flow[node][prev[node]] -= addFlow;
                 node = prev[node];
              }
            }
         }
      }
      return maxFlow;
   }
};

int main()
{
   ifstream in ( "maxflow.in" );
   ofstream out ( "maxflow.out" );

   MaxFlow flow;

   int V, E; in >> V >> E;
   flow.source = 1; flow.sink = V;
   for ( int idx = 1; idx <= E; idx ++ ) {
      int u, v, t; in >> u >> v >> t;
      flow.add_edge ( u, v, t );
   }
   out << flow.solve ();
    return 0;
}