#include <bits/stdc++.h>
using namespace std;

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

int n, m;

struct edge{
  int to, flow, cap;
  edge(int a, int b){
    to=a, flow=0, cap=b;
  }
};

vector<edge> edges;

struct node{
  int level, ptr;
  vector<int> vec;
  node(){
    level=0;
    ptr=0;
  }
};

int s, d;
vector<node> g;

void addedge(int a, int b, int c){
  edge x(b, c), y(a, 0);
  g[a].vec.push_back(edges.size());
  edges.push_back(x);
  g[b].vec.push_back(edges.size());
  edges.push_back(y);
}

bool bfs(int s){
  for(int i=1;i<g.size();++i){
    g[i].level=-1;
    g[i].ptr=0;
  }
  g[s].level=0;
  queue<int> q;
  q.push(s);
  while(!q.empty()){
    int nod=q.front();
    q.pop();
    for(auto i:g[nod].vec){
      int dest=edges[i].to;
      if(g[dest].level!=-1||edges[i].cap<=edges[i].flow) continue;
      q.push(dest);
      g[dest].level=g[nod].level+1;
    }
  }
  return g[d].level!=-1;
}

int dfs(int nod, int pushed){
  if(pushed==0) return 0;
  if(nod==d) return pushed;
  for(int &i=g[nod].ptr;i<g[nod].vec.size();++i){
    int e=g[nod].vec[i];
    if((g[edges[e].to].level==g[nod].level+1)&&(edges[e].cap-edges[e].flow>0)){
      int sent=dfs(edges[e].to, min(edges[e].cap-edges[e].flow, pushed));
      if(sent==0) continue;
      edges[e].flow+=sent;
      edges[e^1].flow-=sent;
      return sent;
    }
  }
  return 0;
}

int getflow(){
  int sol=0;
  while(bfs(s)){
    while(long long pushed=dfs(s, (1<<30))){
      sol+=pushed;
    }
  }
  return sol;
}

int main()
{
  fin>>n>>m;
  g.resize(n+1);
  s=1, d=n;
  for(int i=1;i<=m;++i){
    int a, b, c;
    fin>>a>>b>>c;
    addedge(a, b, c);
  }
  fout<<getflow();
  return 0;
}