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

using namespace std;
ifstream in ("maxflow.in");
ofstream out ("maxflow.out");

int const nmax = 1000;

struct Edge {
  int to;  //g[from][i].to imi da muchia from->to
  int rev; //g[to][rev] imi da muchia to->from
  int cap;
  int flow;
};

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

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

int dist[1 + nmax];

bool bfs() {
  fill(dist + 1, dist + n + 1, -1);

  queue<int> q;
  q.push(src);
  dist[src] = 0;

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

int dfs(int from, int deltaflow) { //dfs e facut pe level graph, nu pe graf
  if(from == dest){
    return deltaflow;
  } else {
    for(int i = 0 ; i < g[from].size() ;i++){
      Edge &e = g[from][i];
      if(dist[from] + 1 == dist[e.to]){
        int delta = dfs(e.to, min(deltaflow, e.cap - e.flow));
        if(0 < delta){
          e.flow += delta;
          g[e.to][e.rev].flow -= delta;
          return delta;
        }
      }
    }
    return 0;
  }
}

int maxflow() {
  int answer = 0;
  while(bfs()) {
    int deltaflow = dfs(src, INT_MAX);
    while(0 < deltaflow) {
      answer += deltaflow;
      deltaflow = dfs(src, INT_MAX);
    }
  }
  return answer;
}

int main() {
  in >> n >> m;
  src = 1;
  dest = n;

  for(int i = 0 ; i < m ;i++){
    int x, y, z;
    in >> x >> y >> z;
    cost[x][y] = z;
  }
  for(int i = 1 ; i < n; i++){
    for(int j = i + 1 ; j <= n; j++){
      if(cost[i][j] != 0 || cost[j][i] != 0) {
        addedge(i, j); //in problemele de flux sunt obligat sa inserez ambele muchii
      }
    }
  }
  out<<maxflow()<<endl;
  return 0;
}