#include<fstream>
#include<vector>
#include<queue>
#include<iostream>

#define MAXN 1001
#define INF 10000001

using namespace std;
typedef int var;

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

var C[MAXN][MAXN], F[MAXN][MAXN], WORK[MAXN];
vector<var> G[MAXN];

var s, t;
var n;

void citire() {
    var m, a, b, c;
    fin>>n>>m;
    while(m--) {
        fin>>a>>b>>c;
        G[a].push_back(b);
        G[b].push_back(a);
        C[a][b] = c;
    }

    s = 1;
    t = n;
}

var DIST[MAXN];
queue<var> Q;
bool bfs() {
    while(!Q.empty()) Q.pop();
    fill(DIST + 1, DIST + n + 1, -1);

    Q.push(s);
    DIST[s] = 0;

    while(!Q.empty()) {
        var node = Q.front();
        Q.pop();
        for(vector<var>::iterator it = G[node].begin(); it != G[node].end(); ++it) {
            var vec = *it;
            if(DIST[vec] == -1 && F[node][vec] < C[node][vec]) {
                DIST[vec] = DIST[node] + 1;
                Q.push(vec);
            }
        }
    }

    return (DIST[t] != -1);
}

var dfs_min (var node, var MIN) {
    if(node == t) return MIN;

    for(var &i = WORK[node]; i<G[node].size(); ++i) {
        var vec = G[node][i];
        if(DIST[vec] == DIST[node] + 1) {
            if(F[node][vec] >= C[node][vec]) cout<<"EROARE!";
            MIN = min(MIN, C[node][vec] - F[node][vec]);

            MIN = dfs_min(vec, MIN);
            if(MIN > 0) {
                F[node][vec] += MIN;
                F[vec][node] -= MIN;
                return MIN;
            }
        }
    }
    return 0;
}

var maxflow() {
    while(bfs()) {
        fill(WORK+1, WORK+n+1, 0);
        while(dfs_min(s, INF));
    }

    var flow = 0;
    for(vector<var>::iterator it = G[s].begin(); it != G[s].end(); ++it) {
        flow += F[s][*it];
    }
    return flow;
}

int main() {
    citire();
    fout<<maxflow();
    return 0;
}