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

#define MAXN 1001
#define MAXC 110002

using namespace std;

FILE *f, *g;

uint8_t N, M;
uint8_t F[MAXN][MAXN];
uint8_t C[MAXN][MAXN];
uint8_t L[MAXN];
bool used[MAXN];
vector<uint8_t> G[MAXN];

void read(void)
{
  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[u][v] = F[v][u] = 0;
  }
  fclose(f);
}

bool AugumentingPath(uint8_t S, uint8_t T)
{
  uint8_t u;
  queue<uint8_t> Q;

  for (int i = 0; i <= N; i++)
    used[ i ] = 0;

  for (Q.push(S), used[S] = 1, u = Q.front(); !Q.empty(); Q.pop())
    if (u != T)
      for (auto v : G[u])
        if (!used[v] && C[u][v] - F[u][v] > 0)
          used[v] = 1, L[v] = u, Q.push(v);

  return used[T];
}

int maxFlowDinic(uint8_t S, uint8_t T)
{
  uint8_t flow = 0;
  uint8_t m = MAXC;

  while (AugumentingPath(S, T))
  {
    for(auto u : G[ T ])
    {
      if (C[ u ][ T ] - F[ u ][ T ] > 0 && used[ u ])
      {
        L[ u ] = T;
        m = MAXC;

        //Find minimum capacity.
        for (auto i = T; i != S; i = L[ i ])
          m = std::min(m, C[ L[i] ][ i ]);

        //Update edges.
        for (auto i = T; i != S; i = L[ i ])
          F[ L[i] ][ i ] -= m,
          F[ i ][ L[i] ] += m;

        //Update flow.
        flow += m;

      }
    }
  }

  return flow;
}

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

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