#include <bits/stdc++.h>

using namespace std;
#define ll long long

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

struct edg {
  int u, v, cap, flow = 0; 
  edg(int a, int b, int c): u(a), v(b), cap(c) {;} 
};

class Dinic {
  public:
    const ll inf = 1e18;
    vector<edg> edge;
    vector<vector<int> > g;
    vector<int> level;
    vector<int> ptr;
    int n, m;
    int s, t;
    Dinic(int a, int b, int c): n(a), s(b), t(c) {
      level.resize(n + 1);
      g.resize(n + 1);
      ptr.resize(n + 1);
    }  
    inline void push(int u, int v, int cap) {
      g[u].push_back(edge.size());
      edge.push_back(edg(u, v, cap));
      g[v].push_back(edge.size());
      edge.push_back(edg(v, u, 0));
      m += 2;
    }
    queue<int> que;
    bool bfs() {
      if(que.empty())
        return level[t] != -1;
      int node = que.front(), c, cap;
      if(node == t)
        return 1;
      //cout << node << '\n';
      que.pop();
      for(auto x : g[node]) {
        if(level[edge[x].v] == -1 && edge[x].cap > edge[x].flow) {
          que.push(edge[x].v);
          level[edge[x].v] = level[node] + 1;
        }
      }
      return bfs();
    }
    ll dfs(int node, ll mn) {
      if(mn == 0)
        return 0;
      if(node == t)
        return mn;
      auto& ref = ptr[node];
      int x;
      for(; ref < g[node].size(); ref++) {
        x = g[node][ref];
        if(level[edge[x].v] != level[node] + 1 
            || edge[x].cap <= edge[x].flow)
          continue;
        ll temp = dfs(edge[x].v, min(mn, (ll)edge[x].cap - (ll)edge[x].flow));
        if(temp == 0)
          continue;
        edge[x].flow += temp;
        edge[x ^ 1].flow -= temp;
        return temp;
      }
      return 0;
    }
    ll flow() {
      ll f = 0;
      while(1) {
        fill(level.begin(), level.end(), -1);
        level[s] = 0;
        que = queue<int>();
        que.push(s);
        if(!bfs())
          break;
        fill(ptr.begin(), ptr.end(), 0);
        ll temp;
        while((temp = dfs(s, inf)) != 0)
          f += temp;
      }
      return f;
    }
};

int main() {
  int n, m;
  cin >> n >> m;
  Dinic flexmaxim(n, 1, n);
  for(int i = 0, x, y, c; i < m; i++) {
    cin >> x >> y >> c;
    flexmaxim.push(x, y, c);
  }
  cout << flexmaxim.flow() << '\n';
}