#include <stdio.h>
#include <vector>

#define MAXN 1000 
#define INFINIT 1000000000

struct Edge {
  int to, flux, rev, total;
};
std::vector<Edge> g[MAXN];
int ult[MAXN], level[MAXN], coada[MAXN], n;

static inline int min(int a, int b) {
  return a < b ? a : b;
}

int bfs() {
  int i, prim, ultim, nod;

  for(i = 0; i < n; i++) {
    level[i] = 0;
  }

  level[0] = 1;
  
  prim = 0;
  ultim = 1;
  coada[0] = 0;
  while(prim != ultim) {
    nod = coada[prim++];

    for(i = 0; i < (int)g[nod].size(); i++) {
      if(g[nod][i].flux < g[nod][i].total && level[g[nod][i].to] == 0) {
        level[g[nod][i].to] = level[nod] + 1;
        coada[ultim++] = g[nod][i].to;
      }
    }
  }

  return level[n - 1] > 0;
}

int dfs(int nod, int minflux) {
  int add;

  if(nod == n - 1) {
    return minflux;
  }

  add = 0;
  while(ult[nod] < (int)g[nod].size() && add == 0) {
    if(level[nod] + 1 == level[g[nod][ult[nod]].to] &&
        g[nod][ult[nod]].flux < g[nod][ult[nod]].total) {
      add = dfs(g[nod][ult[nod]].to, min(minflux,
                  g[nod][ult[nod]].total - g[nod][ult[nod]].flux));
    }
    if(add == 0) {
      ult[nod]++;
    }
  }
  
  if(add > 0) {
    g[nod][ult[nod]].flux += add;
    g[g[nod][ult[nod]].to][g[nod][ult[nod]].rev].flux -= add;
  }
  return add;
}

int main() {
  int m, u, v, w, ans, add, i;
 
  #ifdef LOCAL
    freopen("input.in", "r", stdin);
  #else
    freopen("maxflow.in", "r", stdin);
    freopen("maxflow.out", "w", stdout);
  #endif

  scanf("%d%d", &n, &m);
  while(m--) {
    scanf("%d%d%d", &u, &v, &w);
    u--;
    v--;
    g[u].push_back((struct Edge){.to = v, .flux = 0,
                          .rev = (int)g[v].size(), .total = w});
    g[v].push_back((struct Edge){.to = u, .flux = 0,
                          .rev = (int)g[u].size() - 1, .total = 0});
  }  

  ans = 0;
  while(bfs()) {
    for(i = 0; i < n; i++) {
      ult[i] = 0;
    }

    add = 0;
    do {
      ans += add;
      add = dfs(0, INFINIT);
    } while(add > 0);
  }

  printf("%d\n", ans);
  return 0;
}