#include <bits/stdc++.h>

using namespace std;

#define cin fin
#define cout fout
ifstream cin("maxflow.in");
ofstream cout("maxflow.out");

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;
struct Flow {
  vector<Edg> edg;
  vector<vector<int> > g;
  vector<int> left, layer;
  int s, t, flow;
  void init(int n, int sprim, int tprim) {
    g.resize(n);
    s = sprim;
    t = tprim;
    left.resize(n); layer.resize(n);
  }
  void addedge(int u, int v, int cap) {
    g[u].push_back(edg.size());
    edg.push_back(Edg(v, cap));
    g[v].push_back(edg.size());
    edg.push_back(Edg(u, 0));
  }
  queue<int> que;
  bool bfs() {
    que = queue<int>();
    fill(layer.begin(), layer.end(), -1);
    que.push(s);
    layer[s] = 0;
    while(!que.empty()) {
      int node = que.front();
      que.pop();
      for(auto e : g[node]) {
        if(edg[e].cap > edg[e].flow && layer[edg[e].v] == -1) {
          layer[edg[e].v] = layer[node] + 1;
          que.push(edg[e].v);
        }
      }
    }
    return layer[t] != -1;
  }
  int dfs(int node, int mx = inf) {
    if(node == t)
      return mx;
    for(int i = left[node]; i < g[node].size(); i++) {
      int e = g[node][i];
      if(layer[edg[e].v] != layer[node] + 1 || edg[e].flow == edg[e].cap)
        continue;
      int u = dfs(edg[e].v, min(mx, edg[e].cap - edg[e].flow));
      if(u == 0)
        continue;
      edg[e].flow += u;
      edg[e ^ 1].flow  -= u;
      left[node] = i + 1;
      return u;
    }
    left[node] = g[node].size();
    return 0;
  }
  int mkflow() {
    while(1) {
      fill(left.begin(), left.end(), 0);
      if(!bfs())
        break;
      int temp;
      while((temp = dfs(s)) > 0) flow += temp;
    }
    return flow;
  }
};
Flow 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.mkflow() << '\n';
}