#include <fstream>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
using namespace std;

long minint(long a,long b)
{
 if (a > b)
   {
    return b;
   }
 return a;
}

long N,M;
long Flux;
long finish;

struct TMuchie;
typedef TMuchie *PMuchie;
struct TMuchie
{
 long from,to;
 long c,f;
 PMuchie opp;
};

vector<PMuchie> *Muchii;

long Parinti[1005];
long Parinti2[1005];
long Viz[1005];

long QIn,QOut;
long Coada[1005];

void Push(long a)
{
 Coada[QIn] = a;
 QIn += 1;
}

long Pop(void)
{
 long res = Coada[QOut];
 QOut += 1;
 return res;
}

void BFS(void)
{
 finish = 1;
 memset(Viz,0,1005 * sizeof(long));
 QIn = 0;
 QOut = 0;
 Push(1);
 Parinti[1] = 1;
 Viz[1] = 1;
 while ((QIn - QOut) > 0)
  {
   long x = Pop();
   for (long l = 0;l < Muchii[x].size();l += 1)
    {
     if (Viz[Muchii[x][l]->to] == 1)
       {
        continue;
       }
     if ((Muchii[x][l]->c - Muchii[x][l]->f) > 0)
       {
        if (Muchii[x][l]->to == N)
          {
           finish = 0;

           long t = x;

           long newflow = (Muchii[x][l]->c - Muchii[x][l]->f);
           while (Parinti[x] != x)
            {
             newflow = minint(newflow,
                              (Muchii[Parinti[x]][Parinti2[x]]->c -
                               Muchii[Parinti[x]][Parinti2[x]]->f));
             x = Parinti[x];
            }
           Flux += newflow;

           x = t;
           Muchii[x][l]->f += newflow;
           while (Parinti[x] != x)
            {
             Muchii[Parinti[x]][Parinti2[x]]->f += newflow;
             Muchii[Parinti[x]][Parinti2[x]]->opp->f -= newflow;
             x = Parinti[x];
            }
           continue;
          }
        Parinti[Muchii[x][l]->to] = x;
        Parinti2[Muchii[x][l]->to] = l;
        Push(Muchii[x][l]->to);
        Viz[Muchii[x][l]->to] = 1;
       }
    }
  }
}

int main(void)
{
 long i,a,b,d;
 fstream fin("maxflow.in",ios::in);
 fstream fout("maxflow.out",ios::out);
 Muchii = new vector<PMuchie>[1005];
 fin >> N >> M;
 for (i = 0;i < M;i += 1)
  {
   fin >> a >> b >> d;
   PMuchie m1 = new TMuchie;
   m1->from = a;
   m1->to = b;
   m1->c = d;
   m1->f = 0;
   PMuchie m2 = new TMuchie;
   m2->from = b;
   m2->to = a;
   m2->c = 0;
   m2->f = 0;
   m1->opp = m2;
   m2->opp = m1;
   Muchii[a].push_back(m1);
   Muchii[b].push_back(m2);
  }
 while (finish == 0)
  {
   BFS();
  }
 fout << Flux;
 fin.close();
 fout.close();
 return 0;
}