#include <fstream>
#include <vector>
#include <queue>
#include <climits>
#include <cstring>

#define NMAX 1000

using namespace std;

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

int V, E;
int capacity[NMAX][NMAX];
vector<int> parent;
vector<int> adj[NMAX];

bool BFS() {
    parent.assign(V, -1);
    queue<int> q;
    int currNode = 0;

    q.emplace(currNode);

    while (!q.empty()) {
        currNode = q.front();
        q.pop();

        if (currNode == V - 1) {
            continue;
        }

        for (auto &neighbor: adj[currNode]) {
            if (parent[neighbor] == -1 && capacity[currNode][neighbor] != 0) {
                parent[neighbor] = currNode;
                q.emplace(neighbor);
            }
        }
    }

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

int getMaxFlow() {
    int pathFlow, totalFlow = 0;

    while (BFS()) {
        for (auto &leaf : adj[V - 1]) {
            if (parent[leaf] == -1) {
                continue;
            }

            pathFlow = capacity[leaf][V - 1];

            for (int node = leaf; node != 0; node = parent[node]) {
                pathFlow = min(pathFlow, capacity[parent[node]][node]);
            }

            if (!pathFlow) {
                continue;
            }

            totalFlow += pathFlow;

            capacity[leaf][V - 1] -= pathFlow;
            capacity[V - 1][leaf] += pathFlow;

            for (int node = leaf; node != 0; node = parent[node]) {
                capacity[parent[node]][node] -= pathFlow;
                capacity[node][parent[node]] += pathFlow;
            }

        }
    }

    return totalFlow;
}

int main()
{
    fin >> V >> E;

    memset(capacity, 0, sizeof(capacity));

    int x, y, w;
    for (int i = 0; i < E; ++i) {
        fin >> x >> y >> w;
        --x, --y;
        adj[x].push_back(y);
        adj[y].push_back(x);
        capacity[x][y] = w;
    }

    fout << getMaxFlow();

    return 0;
}