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

#define MAXN 1001
#define MAXC 110001

using namespace std;

int N, M;
int C[MAXN][MAXN];   //Capacity.
int F[MAXN][MAXN];   //Flow.
vector<int> G[MAXN]; //Residual graph.
bool used[MAXN];
int T[MAXN];


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[u].push_back(v);
    G[v].push_back(u);
    C[u][v] = c;
    //C[v][u] = F[v][u] = F[u][v] = 0;
  }
  fclose(f);
}

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

  //Init.
  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 v : G[u])
      {
        if (used[v]==0 && C[u][v] - F[u][v] > 0)
        {
          Q.push(v), T[v] = u, used[v] = 1;
        }
      }
    }
  }

  return used[Terminal];
}

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

  while (augumentingPath(Source, Terminal))
  {
    for (auto u : G[Terminal])
    {
      if (used[u] && C[u][Terminal] - F[u][Terminal] > 0 && (T[Terminal] = u))
      {
        for (tempFlow = MAXC, v = Terminal; v != Source; v = T[v])
        {
          tempFlow = std::min(tempFlow, C[T[v]][v] - F[T[v]][v]);
        }

        //Send flow.
        for (v = Terminal; v != Source; v = T[v])
        {
          F[T[v]][v] += tempFlow, //Forward edge.
          F[v][T[v]] -= tempFlow; //Back edge.
        }

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

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

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