#include <bits/stdc++.h>
#define DIM 1005

using namespace std;

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

int n, m, i, x, y, z, nod, minim, u, fluxsol;
int capacitate[DIM][DIM], flux[DIM][DIM], t[DIM];

bitset <DIM> f;

vector <int> L[DIM];

deque <int> q;

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

int main(){
    fin >> n >> m;
    for (i=1; i<=m; i++){
        fin >> x >> y >> z;
        L[x].push_back(y);
        L[y].push_back(x);
        capacitate[x][y] = 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];
                u = nod;
                while (t[u] != 0){
                    minim = min (minim, capacitate[t[u]][u] - flux[t[u]][u]);
                    u = t[u];
                }
                fluxsol += minim;
                flux[nod][n] += minim;
                flux[n][nod] -= minim;
                u = nod;
                while (t[u] != 0){
                    flux[t[u]][u] += minim;
                    flux[u][t[u]] -= minim;
                    u = t[u];
                }
            }
        }
    }
    fout << fluxsol;
    return 0;
}
//multumim alexandru