#include <iostream>
#include <fstream>
#include <queue>

#define inf  200004

using namespace std;

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

int viz[1024];
int tata[1024];
int capacitate[1024][1024];
int flux[1024][1024];
vector<int> ramas[1024];
int n,m;

int flux_bfs(int source, int sink)
     {
         queue<int> q;
         for(int i=0;i<=n+1;i++)
         {
            viz[i] = 0;
         }

         //Pornim de la nodul de start(1)
         viz[source]=1;
         q.push(source);
         tata[sink] = 0;

         while(!q.empty() && tata[sink]==0)
        {
            int cur = q.front();
            q.pop();

            if(cur == sink)
                continue;

            for(auto vecin: ramas[cur])
            {
                if(capacitate[cur][vecin] - flux[cur][vecin]>0 && !viz[vecin])
                {
                viz[vecin]=1;
                q.push(vecin);
                tata[vecin]=cur;
                }
            }
         }
         return (tata[sink]?true:false);
     }

int fluxmax()
    {
        int rasp = 0;

        for(int i=0;i<=n+1;i++)
            {
                tata[i] = 0;
            }

        while(flux_bfs(1,n))
        {
            for(auto vecin:ramas[n])
            {
                if(flux[vecin][n]!=capacitate[vecin][n] && viz[vecin])
                {
                    tata[n]=vecin;
                    int fmin = inf;
                    int nod=n;

                    while(nod!=1)
                    {
                       if(capacitate[tata[nod]][nod]-flux[tata[nod]][nod]<fmin)
                            fmin = capacitate[tata[nod]][nod]-flux[tata[nod]][nod];
                       nod = tata[nod];
                    }

                    if(fmin==0)
                        continue;

                    nod=n;
                    while(nod!=1)
                    {
                        flux[tata[nod]][nod] += fmin;
                        flux[nod][tata[nod]] -= fmin;
                        nod = tata[nod];
                    }
                    rasp += fmin;

                }
            }
        }
        return rasp;
}
int main()
{       int x,y,s;
        fin>>n>>m;
        for(int i=0;i<m;i++)
        {
            fin>>x>>y>>s;
            capacitate[x][y] = s;
            ramas[x].push_back(y);
            ramas[y].push_back(x);
        }


    fout<<fluxmax()<<" ";

    fin.close();
    fout.close();

    //Complexitate O(mt); m = nr de muchii, t = capacitatea minima a unei taieturi
    return 0;
}