#include <stdio.h>
#include <vector>
#include <queue>
#define nmax 1001
#define oo 0x3f3f3f3f //infinit

using namespace std;

vector <int> G[nmax];
int cap[nmax][nmax];
    bool use[nmax];
queue <int> q;

int flux[nmax][nmax];
int t[nmax];
int n, m;

int bfs (int source, int sink){
    for (int i = 0; i <= n; ++i) use[i] = 0;
    for (int i = 0; i <= n; ++i) t[i] = 0;
    q.push(source);
    use[source] = 1;
    while (!q.empty())     {
        int u = q.front(); //scoatem primul element din coada
        if(u == n) {
            q.pop();
            continue;
        }
        for (int i = 0; i < G[u].size(); ++i) { // pt fiecare nod ( adiacent )
            int dest1 = G[u][i];
            int cap1 = cap[u][dest1];
            if (!use[dest1]) // nu am folosit nodul
                if (cap1 - flux[u][dest1] > 0) // mai putem pompa?
                {
                    q.push(dest1);// inseram nodul i in coada
                    t[dest1] = u;
                    use[dest1] = 1;
                }
        }
        q.pop();
    }
    return use[sink];
}

/*int edmond_karp (int source, int sink){
    int flow = 0; //fluxul
    int i, min;
    while (bfs (source, sink)) // cat timp mai exista un drum de ameliorare
    {
        min = oo;
        for (i = sink; i; i = t[i])
            if (cap[ t[i] ][i] - flux[ t[i] ][i] < min)
                min = cap[ t[i] ][i] - flux[ t[i] ][i];           //calculam minimul dintre capacitatile ramase de pe drum
        for (i = sink ; i; i = t[i])
            flux[ t[i] ][i] += min, //adaugam minimul la fluxul de pe arcele de pe drum
            flux[i][ t[i] ] -= min; //scadem minimul de pe arcele inverse
        flow += min; // adaugam minimul la flux
    }
    return flow;
}
*/

int edmond_karp(int source, int sink){
    int j;
    int minn;
    int flow = 0;
    while(bfs(source, sink)) {
        for(int i = 0; i < G[n].size(); i++)
            if(use[G[n][i]] && flux[G[n][i]][n] < cap[G[n][i]][n]){
                t[n] = G[n][i];
                minn = oo;
                for (j = n; t[j] !=0; j = t[j])
                    if(minn > cap[t[j]][j]-flux[t[j]][j])
                        minn = cap[t[j]][j] - flux[t[j]][j];
                for (j = n; t[j] !=0; j = t[j]) {
                    flux[t[j]][j] += minn;
                    flux[j][t[j]] -= minn;
                }
                flow += minn;
            }
    }
    return flow;
}
int main() {
    int x, y, z;
    freopen ("maxflow.in", "r", stdin);
    freopen ("maxflow.out", "w", stdout);
    scanf ("%d %d", &n, &m);
    for (int i = 1; i <= m; ++i) {
        scanf ("%d %d %d", &x, &y, &z);
        G[x].push_back(y);
        G[y].push_back(x);
        cap[x][y] = z;
    }
    printf ("%d", edmond_karp(1,n));
}