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

using namespace std;

struct Graph {
    vector<vector<int>> cap;

    Graph(int nodes) : cap(nodes, vector<int>(nodes, 0)) {}

    int Size() const {
        return cap.size();
    }
};

bool FindPath(Graph& graph, int source, int sink, vector<int>& prev) {
    prev.clear();
    prev.resize(graph.Size(), -1);
    prev[source] = -2;

    queue<int> q;
    q.push(source);

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

        for (int i = 0; i < graph.Size(); i += 1) {
            if (graph.cap[node][i] > 0 && prev[i] == -1) {
                prev[i] = node;
                q.push(i);
            }
        }
    }
    return prev[sink] != -1;
}

int MinCap(const Graph& graph, int a, int b, const vector<int>& prev) {
    auto min_cap = graph.cap[a][b];
    while (a >= 0) {
        min_cap = min(min_cap, graph.cap[a][b]);
        b = a;
        a = prev[a];
    }
    return min_cap;
}

void Flow(Graph& graph, int a, int b, const vector<int>& prev, int flow) {
    while (a >= 0) {
        graph.cap[a][b] -= flow;
        graph.cap[b][a] += flow;

        b = a;
        a = prev[a];
    }
}

int MaxFlow(Graph& graph, int source, int sink) {
    vector<int> prev;
    int max_flow = 0;

    while (FindPath(graph, source, sink, prev)) {
        for (int i = 0; i < graph.Size(); i += 1) {
            if (graph.cap[i][sink] <= 0) {
                continue;
            }

            auto flow = MinCap(graph, i, sink, prev);
            if (flow <= 0) {
                continue;
            }

            max_flow += flow;
            Flow(graph, i, sink, prev, flow);
        }
    }
    return max_flow;
}

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

    int nodes, edges;
    fin >> nodes >> edges;

    Graph graph(nodes);
    for (int i = 0; i < edges; i += 1) {
        int a, b, cap;
        fin >> a >> b >> cap;
        graph.cap[a - 1][b - 1] = cap;
    }

    auto flow = MaxFlow(graph, 0, nodes - 1);
    fout << flow << "\n";

    return 0;
}