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

using namespace std;

int const nmax = 1000;

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

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

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

void addedge(int i, int j) {
  g[i].push_back({j, g[j].size() , cap[i][j], 0});
  g[j].push_back({i, g[i].size() - 1, cap[j][i], 0});
}

bool bfs() {
  fill(dist + 1, dist + n + 1, -1);
  queue <int> q;

  q.push(src);
  dist[src] = 0;
  while(!q.empty()) {
    int from = q.front();
    for(int k = 0; k < g[from].size(); ++ k) {
      Edge &e = g[from][k];
      if(dist[e.to] < 0 && e.flow < e.cap) {
        dist[e.to] = dist[from] + 1;
        q.push(e.to);
      }
    }
    q.pop();
  }
  return (0 <= dist[dest]);
}

int rem[1 + nmax];
int dfs(int from, int deltaflow) {
  if(from == dest) {
    return deltaflow;
  } else {
    for(int k = rem[from]; k < g[from].size(); ++ k) {
      Edge &e = g[from][k];
      if(dist[e.to] == dist[from] + 1) {
        int addflow = dfs(e.to, min(e.cap - e.flow, deltaflow));
        if(0 < addflow) {
          e.flow += addflow;
          g[e.to][e.rev].flow -= addflow;
          rem[from] = k + 1;
          return addflow;
        }
      }
    }
    return 0;
  }
}

int maxflow() {
  int answer = 0, nr = 0;;
  while(bfs() == 1) {
    int delta;
    do {
      delta = dfs(src, INT_MAX);
      answer += delta;
    } while (0 < delta);
  }
  return answer;
}


int main() {
  in >> n >> m;
  for(int i = 1; i <= m; ++ i) {
    int x, y, z;
    in >> x >> y >> z;
    cap[x][y] = z;
  }
  for(int i=1; i<=n; i++)
    for(int j=i+1; j<=n; j++)
      if(cap[i][j] != 0 || cap[j][i] != 0) {
        addedge(i, j);
      }

  src = 1;
  dest = n;
  out<<maxflow()<<endl;
  return 0;
}