#include <fstream>
#include <algorithm>
#include <queue>
#include <vector>

using namespace std;

const int NMAX = 1007;

ifstream cin("maxflow.in");
ofstream cout("maxflow.out");

int Flux[NMAX][NMAX], Cap[NMAX][NMAX];
int dad[NMAX];
queue < int > q;
int n, m;
vector < int > v[NMAX];

void bfs(int node) {
    q.push(node);
    for(int i = 1; i <= n; ++i) {
        dad[i] = 0;
    }
    dad[node] = -1;
    while(!q.empty()) {
        node = q.front();
        q.pop();
        for(vector < int > :: iterator it = v[node].begin(); it != v[node].end(); ++it) {
            if(dad[*it] == 0 && Cap[node][*it] > Flux[node][*it]) {
                dad[*it] = node;
                q.push(*it);
            }
        }
    }
}

int maxflow() {
    int MaxFlow = 0;
    while(1) {
        bfs(1);
        if(dad[n] == 0) {
            return MaxFlow;
        }
        for(int j = 0; j < v[n].size(); ++j) {
            if(Cap[v[n][j]][n] > Flux[v[n][j]][n] && dad[v[n][j]]) {
                int Min = Cap[v[n][j]][n] - Flux[v[n][j]][n];
                for(int i = v[n][j]; i != 1; i = dad[i]) {
                    Min = min(Min, Cap[dad[i]][i] - Flux[dad[i]][i]);
                }
                MaxFlow += Min;
                Flux[v[n][j]][n] += Min;
                Flux[n][v[n][j]] += Min;
                for(int i = v[n][j]; i != 1; i = dad[i]) {
                    Flux[dad[i]][i] += Min;
                    Flux[i][dad[i]] -= Min;
                }
            }
        }
    }
    return MaxFlow;
}

int main() {
    cin >> n >> m;
    for(int i = 1; i <= m; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        v[a].push_back(b);
        v[b].push_back(a);
        Cap[a][b] += c;
        Flux[a][b] = 0;
    }
    cout << maxflow();
}