#include <bits/stdc++.h>

using namespace std;

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

int n, m, a, b, z, minim, nn, i, nod, fluxsol;
int t[1005];
int capacitate[1005][1005], flux[1005][1005];

vector <int> L[1005];

bitset <1005> f;

deque <int> q;

int bfs (){
    int gasit = 0, vecin, nod;
    q.clear(), f.reset();
    f[1] = 1, q.push_back(1);
    while (!q.empty()){
        nod = q.front();
        q.pop_front();
        for (int i=0; i<L[nod].size(); i++){
            vecin = L[nod][i];
            if (f[vecin] == 0 && capacitate[nod][vecin] > flux[nod][vecin]){
                f[vecin] = 1;
                t[vecin] = nod;
                q.push_back (vecin);
                if (vecin == n){
                    gasit = 1;
                    return 1;
                }
            }
        }
    }
    return gasit;
}

int main(){
    fin >> n >> m;
    for (i=1; i<=m; i++){
        fin >> a >> b >> z;
        L[a].push_back (b);
        L[b].push_back (a);
        capacitate[a][b] = z;
    }
    while (bfs()){
        for (i=0; i<L[n].size(); i++){
            nod = L[n][i];
            if (capacitate[nod][n] > flux[nod][n] && f[nod] == 1){
                minim = capacitate[nod][n] - flux[nod][n];
                nn = nod;
                while (t[nn]){
                    minim = min (minim, capacitate[t[nn]][nn] - flux[t[nn]][nn]);
                    nn = t[nn];
                }
                nn = nod;
                fluxsol += minim;
                flux[nod][n] += minim;
                flux[n][nod] -= minim;
                while (t[nn]){
                    flux[t[nn]][nn] += minim;
                    flux[nn][t[nn]] -= minim;
                    nn = t[nn];
                }
            }
        }
    }
    fout << fluxsol;
    return 0;
}
//recapitulare