#include <vector>
#include <iostream>
#include <fstream>
#include <cstring>
#include <queue>
#include <string>
using namespace std;

#define INFILE "maxflow.in" 
#define OUTFILE "maxflow.out"
#define NMAX 1005
#define INF 0x3f3f3f3f

ifstream fin(INFILE);
ofstream fout(OUTFILE);

vector<int>::iterator it;
int n, s, d;
vector<int> e[NMAX];
int cap[NMAX][NMAX], f[NMAX][NMAX], pre[NMAX], coada[NMAX];
bool vis[NMAX];

int bfs() {
   // bfs from start to destination
   memset(vis, 0, sizeof(vis));
   coada[0] = 0;
   coada[ ++coada[0]] = s;
   vis[s] = 1;
   pre[s] = -1;
   for(int cd = 1;  cd<=coada[0]; cd++ ) {
      int nod = coada[cd];
      if( nod==d ) continue;

      // pass all neighbours, add them to queue if not destination
      for(it=e[nod].begin(); it!=e[nod].end(); it++) 
         // neighbour not visited and there is still capacity on edge
         if( !vis[*it] && cap[nod][*it]>f[nod][*it] ) {
            vis[*it] = 1;
            pre[*it] = nod;
            coada[ ++coada[0]] = *it;
         }
   }
   // return if it is still possible to reach the destination
   return vis[d];
}

int main() {
   int m, a, b, c;
   fin >> n >> m;
   while(m--) {
      fin >> a >> b >> c;
      e[a].push_back(b);
      e[b].push_back(a);
      cap[a][b] = c;
   }

   s = 1, d = n;
   int maxflow = 0;
   while( bfs() ) {
      // traverse all nodes that can lead to destination
      for(it=e[d].begin(); it!=e[d].end(); it++)
         if( vis[*it] && cap[*it][d]>f[*it][d] ) {
            int flow = INF;
            for(int nod = d;flow && pre[nod]!=-1; nod = pre[nod])
               flow = min(flow, cap[pre[nod]][nod] - f[pre[nod]][nod]);

            if(!flow) continue;
            maxflow += flow;
            for(int nod = d; pre[nod]!=-1; nod = pre[nod]) {
               f[pre[nod]][nod] += flow;
               f[nod][pre[nod]] -= flow;
            }
         }
   }
   fout << maxflow;

   return 0;
}