#include <fstream>
#include <vector>
#include <queue>
#include <limits.h>
#include <string.h>
#include <iostream>
#define NMAX 1001

using namespace std;

typedef vector< vector<int> > Graph;


int F[NMAX][NMAX];
int C[NMAX][NMAX];
bool visited[NMAX];
int path[NMAX];
int previous[NMAX];

bool bfs(Graph &graph, int n);

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

    int n, m, fmin, total_flow = 0, prevn;
    fin >> n >> m;

    Graph graph(n + 1);

    int v1, v2, capacity;
    for (int i = 1; i <= m; i++) {
        fin >> v1 >> v2 >> capacity;
        graph[v1].push_back(v2);
        graph[v2].push_back(v1);
        C[v1][v2] += capacity;
    }

    do {
        if(!bfs(graph, n)) {
            break;
        }
        for (unsigned int i = 0; i < graph[n].size(); i++) {
            prevn = graph[n][i];
            if (F[prevn][n] == C[prevn][n] || !visited[prevn]) {
                continue;
            }
            previous[n] = prevn;
            fmin = INT_MAX;
            for (int j = n; j != 1; j = previous[j]) {
                fmin = min(fmin, C[previous[j]][j] - F[previous[j]][j]);
            }

            if (fmin == 0) {
                continue;
            }
            for (int j = n; j != 1; j = previous[j]) {
                F[previous[j]][j] += fmin;
                F[j][previous[j]] -= fmin;
            }
            total_flow += fmin;
        }
    } while (true);

    fout << total_flow;

    return 0;
}


bool bfs(Graph &graph, int n) {
    memset(visited, false, NMAX * sizeof(bool));
    queue<int> bfs_q;

    bfs_q.push(1);
    visited[1] = true;

    int node, next;
    while(!bfs_q.empty()) {
        node = bfs_q.front();
        bfs_q.pop();
        if (node == n) {
            continue;
        }

        for (unsigned int i = 0; i < graph[node].size(); i++) {
            next = graph[node][i];
            if (C[node][next] > F[node][next] && !visited[next]) {
                visited[next] = true;
                bfs_q.push(next);
                previous[next] = node;
            }
        }
    }
    return visited[n];
}