#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()

using namespace std;

#define cin fin
#define cout fout
ifstream cin("maxflow.in");
ofstream cout("maxflow.out");
#define sz(x) (int)(x).size()
struct Edg {
  int v, cap, flow;
  Edg(int b = 0, int c = 0, int d = 0): v(b), cap(c), flow(d) {;}
  
};
const int inf = 21e8 + 5;
using pii = pair<int,int>;

struct Dinic {
  struct Edg {
    int other, flow, cap;
  };
  vector<vector<int>> g;
  vector<Edg> edg;
  vector<int> level, ptr;
  int S, T;
  int accum;
  void init(int s, int t, int n) {
    tie(S, T) = pii{s, t};
    edg.clear();
    level.clear();
    level.resize(n, -1);
    ptr.clear();
    ptr.resize(n, 0);
    g.clear();
    g.resize(n);
    accum = 0;
  }
  void addedge(int a, int b, int c) {
    //cerr << a << ' ' << b << '\t' << c << '\n';
    g[a].emplace_back(sz(edg));
    edg.emplace_back(Edg{b, 0, c});
    
    g[b].emplace_back(sz(edg));
    edg.emplace_back(Edg{a, 0, 0});
  }
  
  bool bfs() {
    queue<int> que;
    fill(all(level), -1);
    level[S] = 0;
    que.emplace(S);
    while(!que.empty()) {
      //cerr << level[T] << ' ';
      int node = que.front();
      que.pop();
      for(auto e : g[node]) {
        if(edg[e].flow != edg[e].cap && level[edg[e].other] == -1) {
          level[edg[e].other] = level[node] + 1;
          que.emplace(edg[e].other);
        }
      }
    }
    return level[T] != -1;
  }
  
  int dfs(int node, int accum = inf) {
    if(accum == 0) return 0;
    if(node == T) return accum;
    for(int &i = ptr[node]; i < g[node].size(); i++) {
      int e = g[node][i];
      if(level[edg[e].other] != level[node] + 1 || edg[e].flow == edg[e].cap) continue;
      int rez = dfs(edg[e].other, min(accum, edg[e].cap - edg[e].flow));
      if(rez == 0) continue;
      edg[e].flow += rez;
      edg[e ^ 1].flow -= rez;
      return rez;
    }
    return 0;
  }
  
  int flux() {
    while(1) {
      if(!bfs()) break;
      fill(all(ptr), 0);
      int tmp;
      while(tmp = dfs(S)) { accum += tmp; }
    }
    return accum;
  }
};

Dinic flex;
int main() {
  int n, m, x, y, c;
  cin >> n >> m;
  flex.init(n + 2, 1, n);
  for(int i = 0; i < m; i++) {
    cin >> x >> y >> c;
    flex.addedge(x, y, c);
  } 
  cout << flex.flux() << '\n';
}