#include <cstdio>
#include <string.h>
#include <vector>

using namespace std;

namespace mf {
// ????? modifica NMAX
#define NMAX 1024
#define vii vector<vector<int> >
#define vi vector<int>
#define pb(a) push_back(a)
int N; // nr noduri
int C[NMAX][NMAX]; // capacitati
int F[NMAX][NMAX]; // flow
vii G;
int coada[NMAX];
int viz[NMAX];
int BFS[NMAX];
inline int bfs(int sursa, int sink) {
  for (int i = 1; i <= N; ++i) viz[i] = 0;
  coada[0] = 0;
  coada[++coada[0]] = sursa;
  viz[sursa] = 1;
  for (int i = 1; i <= coada[0]; ++i) {
    int nod = coada[i];
    if (nod == sink) continue;
    for (int j = 0; j < G[nod].size(); ++j) {
      int nod2 = G[nod][j];
      if (C[nod][nod2] == F[nod][nod2] || viz[nod2]) continue;
      viz[nod2] = 1;
      coada[++coada[0]] = nod2;
      BFS[nod2] = nod;
    }
  }
  return viz[sink];
}
int max_flow(int sursa, int sink) {
  int flow = 0;
  while (bfs(sursa, sink)) {
    for (int i = 0; i < G[sink].size(); ++i) {
      int nod = G[sink][i];
      if (F[nod][sink] == C[nod][sink] || !viz[nod]) continue;
      int cresc = C[nod][sink] - F[nod][sink];
      BFS[sink] = nod;
      for (nod = sink; nod != sursa; nod = BFS[nod]) cresc = min(cresc, C[BFS[nod]][nod] - F[BFS[nod]][nod]);
      if (cresc == 0) continue;
      for (nod = sink; nod != sursa; nod = BFS[nod]) {
        F[BFS[nod]][nod] += cresc;
        F[nod][BFS[nod]] -= cresc;
      }
      flow += cresc;
    }
  }
  return flow;
}
void clear() {
  N = 0; memset(C, 0, sizeof(C)); memset(F, 0, sizeof(F));
  G.clear(); memset(coada, 0, sizeof(coada)); memset(viz, 0, sizeof(viz)); memset(BFS, 0, sizeof(BFS));
}
void adapt(); // make sure you use in::
} // namespace max-flow

namespace in {
int N, M;
int E[5001][3];
} // namespace in
using namespace in;
int main() {
  freopen("maxflow.in", "r", stdin);
  freopen("maxflow.out", "w", stdout);
  // N, M, A si B.
  scanf("%d %d", &N, &M);
  for (int i = 1; i <= M; ++i) {
    scanf("%d %d %d", &E[i][0], &E[i][1], &E[i][2]);
  }
  mf::adapt();
  return 0;
}

void mf::adapt() {
  clear();
  N = in::N;
  int sursa = 1;
  int sink = N;
  G.resize(N + 1);
  for (int i = 1; i <= M; ++i) {
    C[E[i][0]][E[i][1]] = E[i][2];
    G[E[i][0]].pb(E[i][1]);
    G[E[i][1]].pb(E[i][0]);
  }
  int mf = max_flow(sursa, sink);
  printf("%d\n", mf);
}