#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];

bool bfs(int start, int final) {
    for (int i = 1; i <= n; i++) {
        parent[i] = 0;
    }

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

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

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

    return parent[final];
}

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

    while (bfs(start, final)) {

        for (auto &vec : graph[final]) {
            if (!parent[vec])
                continue;
            int path_flow = INF;
            parent[final] = vec;
            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;
    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;
}