#include<iostream>
#include<fstream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<bitset>
#include<cstring>
#include<queue>
#include<stack>

#define ull unsigned long long
#define ll long long
#define pb push_back
#define FOR(a,b,c) for (int a=b;a<=c; ++a)
#define ROF(a,b,c) for (int a=b;a>=c; --a)
#define INF 550000010

// algoritmul Edmonds-Karp optimizat

using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");
int N,M;
int cap[1010][1010],flow[1010][1010],prg[1010],dad[1010];
// cap[i][j]=capacitatea muchiei (i,j)
// flow[i][j]=fluxul de pe muchia (i,j) la un moment dat
// prg=vectorul parcurgerii bfs
// dad[i]=nodul precedent al lui i in parcurgerea bfs curenta

vector<int> v[1010];
bitset<1010> verif;

bool bfs();

int main()
{
    f>>N>>M;
    FOR (i,1,M) {
        int x,y,c;
        f>>x>>y>>c;
        cap[x][y]=c;
        v[x].pb(y);
        v[y].pb(x);
    }
    int flowtot=0;
    while (bfs()) {
        vector<int>::iterator it;
        for (it=v[N].begin();it<v[N].end();++it) { // verific daca exista un drum de crestere cu ultimele doua noduri dad[D] si D
            if (verif.test(*it) && cap[*it][N]!=flow[*it][N]) {
                int flowc=INF;
                dad[N]=*it;
                for (int i=N;i!=1;i=dad[i]) {
                    flowc=min(flowc,cap[dad[i]][i]-flow[dad[i]][i]);
                }
                if (flowc!=0) {
                    for (int i=N;i!=1;i=dad[i]) {
                        flow[dad[i]][i]+=flowc;
                        flow[i][dad[i]]-=flowc;
                    }
                    flowtot+=flowc;
                }
            }
        }
    }
    g<<flowtot;
    f.close();g.close();
    return 0;
}

bool bfs() {
    int nr=1;
    verif.reset();
    prg[1]=1;
    verif.set(1,1);
    for (int i=1;i<=nr;++i) {
        int nod=prg[i];
        if (nod==N) {
            return 1;
        }
        vector<int>::iterator it;
        for (it=v[nod].begin();it<v[nod].end();++it) {
            if (!verif.test(*it) && cap[nod][*it]!=flow[nod][*it]) {
                verif.set(*it,1);
                dad[*it]=nod;
                prg[++nr]=*it;
            }
        }
    }
    return 0;
}