#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

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

int const nmax = 1000;

//sunt in g[from]
struct Edge {
  int to;
  int rev; //indicele muchiei inverse in g[to]
  int cap;
  int flow;
};

int n, m, src, dest;
vector<Edge> g[1 + nmax];
int cap[1 + nmax][1 + nmax];

void addedge(int i, int j) {
  Edge dir = {j, g[j].size(), cap[i][j], 0};
  Edge inv = {i, g[i].size(), cap[j][i], 0};
  g[i].push_back(dir);
  g[j].push_back(inv);
}

int dist[1 + nmax];

//construim level graph
bool bfs() {
  queue<int> q;
  q.push(src);
  for(int i = 1; i <= n; i ++)
    dist[i] = -1;
  dist[src] = 0;
  while(q.size()) {
    int from = q.front();
    q.pop();
    for(int i = 0; i < g[from].size(); i ++) {
      Edge &e = g[from][i];
      if(e.flow < e.cap && dist[e.to] == -1) {
        dist[e.to] = 1 + dist[from];
        q.push(e.to);
      }
    }
  }
  return (0 <= dist[dest]);
}

int rem[1 + nmax];

//dfs-ul se implementeaza optim cu memorie
int dfs(int from, int deltaflow) {  //deltaflow iti retine deltaflow minim
  if(from == dest)
    return deltaflow;
  else {
    for(int i = rem[from]; i < g[from].size(); i ++) {
      Edge &e = g[from][i];
      if(dist[from] + 1 == dist[e.to]) {
        int addflow = dfs(e.to, min(deltaflow, e.cap - e.flow));
        if(0 < addflow) {
          rem[from] = i;
          e.flow += addflow;
          Edge &rev = g[e.to][e.rev];
          rev.flow -= addflow;
          return addflow;
        }
      }
    }
    //rem[from] = g[from].size();
    return 0;
  }
}

int dinic() {
  int ans  = 0;
  while(bfs()) {
    for(int i = 1; i <= n; i ++)
      rem[i] = 0;
    int aux = dfs(src, INT_MAX);
    while(aux) {
      ans += aux;
      aux = dfs(src, INT_MAX);
    }
  }
  return ans;
}

int main() {

  in >> n >> m;
  src = 1;
  dest = n;
  for(int i = 1; i <= m; i ++) {
    int x, y, c;
    in >> x >> y >> c;
    cap[x][y] = c;
  }

  for(int i = 1; i < n; i ++)
    for(int j = i + 1; j <= n; j ++)
      if(cap[i][j] || cap[j][i])
        addedge(i, j);
  out << dinic();
  return 0;
}