#include <bits/stdc++.h>

using namespace std;

const int MAX_N = 1000;
vector<int> graph[1+MAX_N];
int kappa[1+MAX_N][1+MAX_N], papa[1+MAX_N], q[MAX_N];
bool viz[1+MAX_N];
int flow;

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

static inline void pump(int nod) {
  int i = nod, cant = 1000000000;
  while(i > 1) {
    int j = papa[i];
    cant = min(cant, kappa[j][i]);
    i = j;
  }
  while(nod != 1) {
    int i = papa[nod];
    kappa[i][nod] -= cant;
    kappa[nod][i] += cant;
    nod = i;
  }
  flow += cant;
}

static inline bool augment(int n) {
  int st, dr;
  bool pompat = false;
  st = dr = 0;
  q[dr++] = 1;
  memset(viz + 1, 0, sizeof(bool) * n);
  viz[1] = true;
  while(st < dr && !viz[n]) {
    int nod = q[st++];
    for(auto it: graph[nod])
      if(kappa[nod][it] > 0 && !viz[it] && it != n) {
        viz[it] = true;
        q[dr++] = it;
        papa[it] = nod;
      } else if(it == n && kappa[nod][it] > 0) {
        papa[it] = nod;
        pump(n);
        pompat = true;
      }
  }
  return pompat;
}

int main() {
  int n, m, a, b, c;
  FILE *fin = fopen("maxflow.in", "r");
  fscanf(fin, "%d%d", &n, &m);
  for(int i = 0; i < m; ++i) {
    fscanf(fin, "%d%d%d", &a, &b, &c);
    kappa[a][b] = c;
    graph[a].push_back(b);
    graph[b].push_back(a);
  }
  fclose(fin);

  for(int i = 1; i <= n; ++i)
    random_shuffle(graph[i].begin(), graph[i].end());

  while(augment(n));

  FILE *fout = fopen("maxflow.out", "w");
  fprintf(fout, "%d", flow);
  fclose(fout);
  return 0;
}

//cu optimizarea arborelui DFS