#include <bits/stdc++.h>

using namespace std;
using T = int;

struct Dinic {
  struct Edge { int from, to, nxt; T cap, flow; };
   
  vector<Edge> es;
  vector<int> graph, at, dist, q;
  
  Dinic(int n) : graph(n, -1) {}
  
  int AddEdge(int a, int b, T c) {
    auto add = [&](int a, int b, T c) {
      es.push_back({a, b, graph[a], c, 0});
      graph[a] = es.size() - 1;
    };
    add(a, b, c); add(b, a, 0);
    return es.size() - 2;
  } 
  bool bfs(int src, int dest, T need) {
    dist.assign(graph.size(), -1); q.clear();
    dist[src] = 0; q.push_back(src);
    for (int i = 0; i < (int)q.size(); ++i) {
      int node = q[i];
      for (int ei = graph[node]; ei >= 0; ei = es[ei].nxt) {
        const auto &e = es[ei];
        if (dist[e.to] == -1 && e.cap - e.flow >= need) {
          dist[e.to] = dist[node] + 1;
          q.push_back(e.to);
        }
      }
    }
    return dist[dest] != -1;
  }
  T dfs(int node, int dest, T need, T req) {
    if (need < req) return 0;
    if (node == dest) return need;
    T ret = 0;
    for (int& ei = at[node]; ei != -1; ei = es[ei].nxt) {
      const auto &e = es[ei];
      if (dist[e.to] != dist[node] + 1) continue;
      if (T now = dfs(e.to, dest, min(need, e.cap - e.flow), req)) {
        es[ ei ].flow += now;
        es[ei^1].flow -= now;
        ret += now; need -= now;
      }
      if (!need) break;
    }
    return ret;
  }
  T Compute(int src, int dest) {
    T ret = 0;
    for (T step = (1 << 16); step; step /= 2) { // (*)
      while (bfs(src, dest, step)) {
        at = graph;
        ret += dfs(src, dest, numeric_limits<T>::max(), step);
      }
    }
    return ret;
  }
};

int main() {
  ifstream cin("maxflow.in");
  ofstream cout("maxflow.out");
  int n, m; cin >> n >> m;
  Dinic D(n);
  for (int i = 0; i < m; ++i) {
    int a, b, c; cin >> a >> b >> c; 
    D.AddEdge(a - 1, b - 1, c);
  }
  cout << D.Compute(0, n - 1) << endl;
  return 0;
}