#include <iostream>
#include <queue>
#include <fstream>
#include <algorithm>
#include <cmath>

using namespace std;

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

int inf = 100000;
vector<int> tata (1002,0),viz(1002,0);
int out[1002],in[1002];
int gr[1002][1002];
int ca[1002][1002];
vector <int> ad[1002];
///o sa implementez a doua varianta prezentata la curs - gasesc fluxul
/// maxim folosindu-ma de graful rezidual si retin arborele bfs cu ajutorul
///unui array de tati
/// de asemenea, o sa retinem  graful folosindu-ne de o matrice de adiacenta
/// pentru care g[i][j] = capacitatea arcului cu extremitatiile (i,j) daca (i,j) apartine lui E
//                        0, altfel

int n, m, s, t;

///o sa fac un bfs care sa imi intoarca true daca a fost
///gasit un path de la s la t si false altfel
bool bfs()
{

    queue <int> q;
    q.push(s);
    while(!q.empty())
    {
        int nod = q.front();
            for(auto &i: ad[nod])
            {
                if(gr[nod][i] && viz[i] == 0)
                {
                    q.push(i);
                    viz[i] = 1;
                    tata[i] = nod;
                     if( i == t)
                         return true;
                }
            }
        q.pop();
    }
    return false;

}
int main()
{
    int flux = 0;
    fin >> n >> m;
    s = 1;
    t = n;
    bool wrong = false;
    for(int i  = 1; i <=m ; i++)
    {
        int a,b,c;
        fin>>a>>b>>c;
        ca[a][b] = c;
        ad[a].push_back(b);
        ad[b].push_back(c);
        ///in graful rezidual semnalam ca putem sa trimitem c - d "obiecte"
        /// de la a la b si sa trimitem inapoi d "obiecte" de la b la a
        gr[a][b] = c;
    }
    viz[s] = 1;
    while(bfs())
    {

        ///vream sa computam i(P)  - capacitatea reziduala a drumului P in graful rezidual
        int nod = t;
        int capacity = inf;
        while(nod != s)
        {
            capacity = min(capacity,gr[tata[nod]][nod]);
            nod = tata[nod];

        }
        ///revizuim drumul si actualizam graful rezidual
        nod = t;
        while(nod != s)
        {

            gr[tata[nod]][nod] -= capacity;
            gr[nod][tata[nod]] += capacity;
            nod = tata[nod];
        }
        fill(tata.begin(),tata.end(),0);
        fill(viz.begin(),viz.end(),0);
        viz[s] = 1;

    }
    for(auto &nod: ad[s])
    {
        if(ca[s][nod])
            flux += gr[nod][s];
    }
    fout<<flux<<"\n";
    return 0;
}