#include <iostream>
#include <vector>
#include <cassert>
#include <cmath>
#include <algorithm>
#include <queue>
#include <fstream>

std::ifstream in ("maxflow.in");
std::ofstream out ("maxflow.out");

using ll = long long;
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))

int const inf = 1000000000;

class Graph{
private:
  struct Edge{
    int to;
    int rev;
    int flow;
    int cap;
  };
  std::vector<std::vector<Edge>> g;
  std::vector<int> level, rem;
  int n;
public:
  Graph(int n_) {
    n = n_;
    g.resize(1 + n);
    level.resize(1 + n);
    rem.resize(1 + n);
  }
  void add_edge(int x, int y, int cap) {
    g[x].push_back({y, g[y].size(), 0, cap});
    g[y].push_back({x, g[x].size(), 0, 0});
  }
  bool bfs() {
    for(int i = 1;i <= n; i++)
      level[i] = -1;
    std::queue<int> q;

    q.push(1);
    level[1] = 1;
    while(0 < q.size()) {
      int node = q.front();
      q.pop();
      for(int h = 0; h < g[node].size(); h++) {
        Edge e = g[node][h];
        if(level[e.to] == -1 && e.flow < e.cap) {
          level[e.to] = level[node] + 1;
          q.push(e.to);
        }
      }
    }
    return (0 <= level[n]);
  }
  int dfs(int node, int delta) {
    if(node == n)
      return delta;
    else {
      for(int &h = rem[node]; h < g[node].size(); h++) {
        Edge &e = g[node][h];
        if(e.flow < e.cap && level[node] + 1 == level[e.to]) {
          int result = dfs(e.to, std::min(delta, e.cap - e.flow));
          if(0 < result) {
            e.flow += result;
            g[e.to][e.rev].flow -= result;
            return result;
          }
        }
      }
      return 0;
    }
  }

  ll maxflow() {
    ll result = 0, delta = 0;
    while(bfs()) {
      for(int i = 1;i <= n; i++)
        rem[i] = 0;
      do {
        result += delta;
        delta = dfs(1, inf);
      } while(0 < delta);
    }
    return result;
  }
};

int main() {

  int n, m;
  in >> n >> m;
  Graph graph(n);
  for(int i = 1;i <= m; i++) {
    int x, y, cap;
    in >> x >> y >> cap;
    graph.add_edge(x, y, cap);
  }
  out << graph.maxflow();
}