#include <iostream>
#include <fstream>
#include <vector>


using namespace std;
const int NMAX = 1e3;
const int MMAX = 5e3;
const int INF = 2e9;

struct define_edge {
      int flow, capacity;
} matrix[1 + NMAX][1 + NMAX];
vector<int> graph[1 + NMAX];
bool visited[1 + NMAX];
int source, sink;
int n, m;

static inline int remaining_capacity ( int u, int v ) {
      return matrix[u][v].capacity - matrix[u][v].flow;
}

void reset_vis () {
    for ( int i = 1; i <= n; i ++ )
       visited[i] = false;
}
void augment_edge ( int u, int v, int bottleneck ) {
    matrix[u][v].flow += bottleneck;
    matrix[v][u].flow -= bottleneck;
}

int delta;
void get_delta ( int maxx_cap ) {
   delta = 1;
   while ( delta <= maxx_cap )
      delta *= 2;
   delta /= 2;
}

int dfs ( int node, int maxFlow ) {
   if ( node == sink )
     return maxFlow;
   visited[node] = true;
   for ( auto next : graph[node] ) {
      int canditate = remaining_capacity ( node, next );
      if ( canditate >= delta && !visited[next] ) {
         int bottleneck = dfs ( next, min ( maxFlow, canditate ) );
         if ( bottleneck > 0 ) {
           augment_edge ( node, next, bottleneck );
           return bottleneck;
         }
      }
   }
   return 0;
}

int solve_flow () {
   int answer = 0;
   while ( delta ) {

      int flow_of_delta;
      do {
        flow_of_delta = dfs ( source, INF );
        answer += flow_of_delta;
        reset_vis ();
      }
      while ( flow_of_delta != 0 );
      delta /= 2;
   }
   return answer;
}


ifstream fin ( "maxflow.in" );
ofstream fout ( "maxflow.out" );
int main()
{
   fin >> n >> m;
   int maxx_cap = -INF;
   source = 1, sink = n;
   for ( int i = 1; i <= m; i ++ ) {
      int u, v, cap; fin >> u >> v >> cap;
      maxx_cap = max ( maxx_cap, cap );
      matrix[u][v] = { 0, cap };
      graph[u].push_back ( v );
      graph[v].push_back ( u );
   }

   get_delta ( maxx_cap );
   fout << solve_flow ();

    return 0;
}