#include <bits/stdc++.h>

using namespace std;

const int inf = 1000000000;

struct Edge {
  int to, flow, cap, rev;
};

class maxFlow {
private:
  int n;
  vector<vector<Edge>> g;
  vector<int> dist, rem;
  int s, d;
public:
  maxFlow(int n, int s, int d) {
    this->n = n;
    this->s = s;
    this->d = d;
    g.resize(1 + n);
    dist.resize(1 + n);
    rem.resize(1 + n);
  }
  void addEdge(int from, int to, int cap) {
    g[from].push_back({to, 0, cap, g[to].size()});
    g[to].push_back({from, 0, 0, g[from].size() - 1});
  }
  bool bfs(){
    for(int i = 1;i <= n; i++)
      dist[i] = inf;
    queue<int> q;
    q.push(s);
    dist[s] = 0;
    while(!q.empty()){
      int node = q.front();
      q.pop();
      for(int h = 0; h < g[node].size(); h++){
        Edge e = g[node][h];
        if(dist[node] + 1 < dist[e.to] && e.flow < e.cap){
          dist[e.to] = dist[node] + 1;
          q.push(e.to);
        }
      }
    }
    return inf != dist[d];
  }
  int dfs(int node, int deltaflow){
    if(node == d)
      return deltaflow;
    else{
      for(int &h = rem[node]; h < g[node].size(); h++){
        Edge &e = g[node][h];
        if(dist[node] + 1 == dist[e.to] && e.flow < e.cap){
          int flow = dfs(e.to, min(deltaflow, e.cap - e.flow));
          if(0 < flow){
            e.flow += flow;
            g[e.to][e.rev].flow -= flow;
            return flow;
          }
        }
      }
      return 0;
    }
  }
  int maxflow(){
    int result = 0;
    while(bfs()){
      for(int i = 1;i <= n; i++)
        rem[i] = 0;
      int deltaflow = dfs(s, inf);
      while(0 < deltaflow){
        result += deltaflow;
        deltaflow = dfs(s, inf);
      }
    }
    return result;
  }
};

int main() {
  freopen("maxflow.in", "r", stdin);
  freopen("maxflow.out", "w", stdout);

  int n, m;
  scanf("%d%d", &n, &m);
  maxFlow net(n, 1, n);
  for (int i = 1; i <= m; ++i) {
    int u, v, c;
    scanf("%d%d%d", &u, &v, &c);
    net.addEdge(u, v, c);
  }

  printf("%d\n", net.maxflow());

  return 0;
}