#include <bits/stdc++.h>
using namespace std;
 
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
 
const int MAXN = 1001;
const int INF = 1e9;
 
int n, m;
int C[MAXN][MAXN], F[MAXN][MAXN], t[MAXN];
vector <int> G[MAXN];
 
static inline bool BFS() {
  queue <int> Q;
  memset(t, 0, sizeof(t));
  
  t[1] = -1;
  Q.push(1);
  
  bool found = 0;
  while(!Q.empty()) {
    int nod = Q.front();
    Q.pop();
    
    for(auto vecin : G[nod])
      if(!t[vecin] && F[nod][vecin] < C[nod][vecin]) {
        if(vecin != n) {
          t[vecin] = nod;
          Q.push(vecin);
        }
        else
					found = 1; // Am gasit un drum de ameliorare
			}
  }
  return found;
}
 
static inline int Dinic() {
  int flux = 0;
  while(BFS()) {
    for(int vecin : G[n]) {
      if(t[vecin] && C[vecin][n] > F[vecin][n]) {
        t[n] = vecin;
 
				int minim = INF;
				for(int i = n; i > 1; i = t[i])
					minim = min(minim, C[t[i]][i] - F[t[i]][i]);
 
        if(minim > 0) {
					flux += minim;
					for(int i = n; i > 1; i = t[i]) {
						F[t[i]][i] += minim;
						F[i][t[i]] -= minim;
					}
				}
      }
    }
  }
 
  return flux;
}
 
int main() {
  fin >> n >> m;
  for(int i = 1; i <= m; i++) {
    int x, y, c;
    fin >> x >> y >> c;
    
    G[x].push_back(y);
    G[y].push_back(x);
    C[x][y] = c;
  }
 
  fout << Dinic();
 
  return 0;
}