#include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>

#define MAXN 1001
#define MAXC 110001

using namespace std;

int N, M;

struct Edge
{
  int v; //vertex.
  int c; //capacity.
  //int flow; //flow.
  int index; //index of back edge in G.
};

struct Special
{
  int v; //vertex.
  int index; //index.
};

class Graph
{
private:
  vector<Edge> G[MAXN];
  Special T[MAXN];
  bool used[MAXN];

public:
  Graph();
  ~Graph();

public:
  void AddEdge(int u, int v, int c);
  bool augumentingPath(int Source, int Terminal);
  int maxFlowDinic(int Source, int Terminal);
};

Graph::Graph()
{

}

Graph::~Graph()
{

}

void Graph::AddEdge(int u, int v, int c)
{
  Edge a {v, c, G[v].size()};
  Edge b {u, c, G[u].size()};

  this->G[u].push_back(a);
  this->G[v].push_back(b);
}

bool Graph::augumentingPath(int Source, int Terminal)
{
  queue<int> Q;
  int u = 0;

  for (size_t i = 0; i <= Terminal; i++)
    used[i] = 0;

  for (Q.push(Source), used[Source] = 1, u = Q.front(); !Q.empty(); Q.pop(), u = Q.front())
  {
    if (u != Terminal)
    {
      for (auto e : G[u])
      {
        if (used[e.v] == 0 && e.c > 0)
        {
          Q.push(e.v), T[e.v] = {u, G[e.v][e.index].index}, used[e.v] = 1;
        }
      }
    }
  }

  return used[Terminal];
}

int Graph::maxFlowDinic(int Source, int Terminal)
{
  int totalFlow = 0;
  int tempFlow = MAXC;
  int v;

  while (Graph::augumentingPath(Source, Terminal))
  {
    for (auto e : G[Terminal])
    {
      if (used[e.v] && G[e.v][e.index].c > 0)
      {
        T[Terminal] = {e.v, G[e.v][e.index].index };

        for (tempFlow = MAXC, v = Terminal; v != Source; v = T[v].v)
        {
          tempFlow = std::min(tempFlow, G[ T[v].v ][ G[v][T[v].index].index ].c );
        }

        for (v = Terminal; v != Source; v = T[v].v)
        {
          G[v][T[v].index].c += tempFlow;
          G[T[v].v][ G[v][T[v].index].index].c -= tempFlow;
        }

        totalFlow += tempFlow;
      }
    }
  }
  return totalFlow;
}

Graph G;


void read(void)
{
  FILE * f = fopen("maxflow.in", "r");
  fscanf(f, "%d %d", &N, &M);
  for (size_t i = 0, u, v, c; i < M; i++)
  {
    fscanf(f, "%d %d %d", &u, &v, &c);
    G.AddEdge(u, v, c);
  }
  fclose(f);
}

void write(void)
{
  FILE * g = fopen("maxflow.out", "w");
  fprintf(g, "%d", G.maxFlowDinic(1, N));
  fclose(g);
}

int main()
{
  read();
  write();
  return 0;
}