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

using namespace std;

const int NMAX = 1002;
const int INF = 2e9;

int n,m;
vector<int> graph[NMAX];
int residual[NMAX][NMAX];
int parent[NMAX];
vector<bool> viz;

bool bfs(int start, int final) {
    fill(viz.begin(), viz.end(), false);

    queue<int> q;
    q.push(start);
    viz[start] = true;
    parent[start] = -1;

    while (!q.empty() && !viz[final]) {
        int u = q.front();
        q.pop();

        for (auto &v : graph[u]) {
            if (!viz[v] && residual[u][v] > 0) {
                q.push(v);
                viz[v] = true;
                parent[v] = u;
            }
        }
    }

    return viz[final];
}

int fordFulkerson (int start, int final) {
    int max_flow = 0;
    int u,v;

    while (bfs(start, final)) {
        int path_flow = INF;

        v = final;
        while (v != start) {
            u = parent[v];
            path_flow = min(path_flow, residual[u][v]);
            v = parent[v];
        }

        v = final;
        while (v != start) {
            u = parent[v];
            residual[u][v] -= path_flow;
            residual[v][u] += path_flow;
            v = parent[v];
        }

        max_flow += path_flow;
    }

    return max_flow;
}

int main() {

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

    fin >> n >> m;
    viz.resize(n + 1);
    for (int i = 0; i < m; i++) {
        int x, y, c;
        fin >> x >> y >> c;
        graph[x].push_back(y);
        graph[y].push_back(x);
        residual[x][y] = c;
    }

    fout << fordFulkerson(1,n);

    fin.close();
    fout.close();
    return 0;
}