#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <utility>
#include <algorithm>
#include <cstring>

#define BUF_SIZE 1<<17
char buffer[BUF_SIZE];
int pbuf = BUF_SIZE;
FILE *fi, *fo;
inline char nextch(){
    if(pbuf == BUF_SIZE){
        fread(buffer, BUF_SIZE, 1, fi);
        pbuf=0;
    }
    return buffer[pbuf++];
}
inline long long nextnum(){
    long long a = 0;
    char c = nextch();
    while((c < '0' || c > '9') && c != '-')
        c = nextch();
    int semn = 1;
    if(c == '-'){
        semn = -1;
        c = nextch();
    }
    while('0' <= c && c <= '9'){
        a = a*10+c-'0';
        c = nextch();
    }
    return a*semn;
}

#define MAXN 1024
#define INF 2000000000

int n, m;
std::vector < int > G[1 + MAXN];
int C[1 + MAXN][1 + MAXN];
int F[1 + MAXN][1 + MAXN];
int q[1 + MAXN];
int father[1 + MAXN];
int viz[1 + MAXN];

int bfs(){
    q[0] = 1;
    q[1] = 1;
    memset(viz, 0, sizeof(viz));
    viz[1] = 1;

    for(int i = 1; i <= q[0]; i++){
        int node = q[i];
        if(node != n)
            for(int j = 0; j < G[node].size(); j++){
                int vecin = G[node][j];
                if(!viz[vecin] && C[node][vecin] != F[node][vecin]){
                    viz[vecin] = 1;
                    q[++q[0]] = vecin;
                    father[vecin] = node;
                }
            }
        if(viz[n])
            return viz[n];
    }

    return viz[n];
}

inline int minim(int a, int b){
    return a < b ? a : b;
}

int main(){
    fi = fopen("maxflow.in","r");
    fo = fopen("maxflow.out","w");

    //n = nextnum();
    //m = nextnum();
    fscanf(fi,"%d%d", &n, &m);
    for(int i = 0; i <= m; i++){
        //int x = nextnum(), y = nextnum(), z = nextnum();
        int x, y, z;
        fscanf(fi,"%d%d%d", &x, &y, &z);
        C[x][y] += z;
        G[x].push_back(y);
        G[y].push_back(x);
    }

    int flow = 0;
    while(bfs())
        for(int i = 0; i < G[n].size(); i++){
            int node = G[n][i];
            if(viz[node] && C[node][n] != F[node][n]){
                father[n] = node;

                int fmin = INF;
                for(int node = n; node != 1; node = father[node])
                    fmin = minim(fmin, C[father[node]][node] - F[father[node]][node]);
                if(fmin != 0){
                    for(int node = n; node != 1; node = father[node]){
                        F[father[node]][node] += fmin;
                        F[node][father[node]] -= fmin;
                    }
                    flow += fmin;
                }
            }
        }

    fprintf(fo,"%d", flow);
    fclose(fi);
    fclose(fo);
    return 0;
}