#include <fstream>
#include <cstring>

#include <vector>
#define DIMN 1010
#define INF 111000

using namespace std;

int C[DIMN][DIMN];
int F[DIMN][DIMN];

char v[DIMN];
int t[DIMN];
int q[DIMN];

int n, m, flux, x, y, z, nod, i, minim, u;

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

vector<int> L[DIMN];
vector<int>::iterator it;


int bfs(int nod) {
    for (i=1;i<=n;i++)
        v[i] = 0;
    int p, u;
    p = u = 1;
    q[1] = 1;
    v[1] = 1;
    while (p<=u) {
        nod = q[p];
        for (it = L[nod].begin();it!=L[nod].end(); it++){
            x=*it;
            if(v[x]==0 && C[nod][x] - F[nod][x] > 0) {
                u++;
                q[u]=x;
                v[x]=1;
                t[x] = nod;
                if (x == n)
                    return 1;
            }

        }
        p++;
    }

    return v[n];

}

int main() {
    fin>>n>>m;
    for (i=1;i<=m;i++) {
        fin>>x>>y>>z;
        C[x][y] = z;
        L[x].push_back(y);
        L[y].push_back(x);
    }

    while (bfs(1)) {
        for (it = L[n].begin();it!=L[n].end(); it++) {
            nod = *it;
            if (v[nod] == 1 && C[nod][n] - F[nod][n] > 0) {
                minim = INF;
                u = n;
                while (t[u]) {
                    if (C[ t[u] ][u] - F[ t[u] ][u] < minim) {
                        minim = C[ t[u] ][u] - F[ t[u] ][u];
                    }
                    u = t[u];
                }
                if (minim == 0)
                    continue;

                u = n;
                while (t[u]) {

                    F[ t[u] ][u] += minim;
                    F[u][ t[u] ] -= minim;
                    u = t[u];
                }
            }
        }
    }
    flux = 0;
    for (i=0;i<L[1].size(); i++) {
        flux += F[1][  L[1][i]  ];
    }

    fout<<flux;

    return 0;
}