#include <bits/stdc++.h>
 
using namespace std;
 
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

vector < vector < int > > G;
vector < vector < int > > residual;
vector < int > parent;

int n, m, hi;
bool BFS(int node) {
    parent.assign(n, -1);
    queue < int > Q;

    parent[node] = -2;
    Q.push(node);
    while (!Q.empty()) {
        node = Q.front();
        Q.pop();

        for (auto x: G[node]) {
            if (parent[x] == -1 && residual[node][x]) {
                Q.push(x);
                parent[x] = node;
            }
        }
    }

    return parent[n - 1] != -1;
}

int main() {
    ios::sync_with_stdio(false);

    fin >> n >> m;

    residual.resize(n);
    G.resize(n);
    for (auto &x: residual) x.resize(n);

    for (int i = 0; i < m; ++i) {
        int a, b, c; 
        fin >> a >> b >> c;
        --a; --b;

        residual[a][b] += c;
        G[a].push_back(b);
        G[b].push_back(a);
    }

    int totalFlow = 0;
    parent.resize(n);
    while (BFS(0)) {
        for (auto x: G[n - 1]) {
            if (parent[x] == -1) continue;

            int maxFlow = residual[x][n - 1];
            for (int now = x; now != 0; now = parent[now]) {
                int prev = parent[now];
                maxFlow = min(maxFlow, residual[prev][now]);
            }
            for (int now = x; now != 0; now = parent[now]) {
                int prev = parent[now];
                residual[prev][now] -= maxFlow;
                residual[now][prev] += maxFlow;
            }

            totalFlow += maxFlow;
        }
    }

    fout << totalFlow;
    return 0;
}