#include <bits/stdc++.h>

using namespace std;

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

class MaximumFlow {
    static constexpr long long INF = numeric_limits<long long>::max() >> 1;
    int N, source, sink;
    long long limit;
    vector<vector<long long>> capacity;
    vector<vector<int>> adj;
    vector<int> previous;

    bool find_augmenting_path() {
        fill_n(previous.begin(), N, -1);
        queue<int> q({ source });
        previous[source] = 0;

        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (int v : adj[u])
                if (previous[v] == -1 && capacity[u][v] > 0) {
                    previous[v] = u;
                    q.push(v);
                    if (v == sink) return true;
                }
        }

        return false;
    }

public:
    MaximumFlow(int N, int source, int sink)
        : N(N), source(source), sink(sink), limit(), capacity(N, vector<long long>(N)), adj(N), previous(N) {}

    void add_edge(int u, int v, long long capacity) { 
        this->capacity[u][v] = capacity; 
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    long long maximum_flow() {
        long long max_flow = 0;
        for (limit = (1LL << 60); limit; limit >>= 1) {
            while (find_augmenting_path()) {
                long long flow = INF;
                for (int u = sink; u != source; u = previous[u])
                    flow = min(flow, capacity[previous[u]][u]);
                for (int u = sink; u != source; u = previous[u]) {
                    capacity[previous[u]][u] -= flow;
                    capacity[u][previous[u]] += flow;
                }
                max_flow += flow;
            }
        }
        return max_flow;
    }
};

int main() {
    int N, M;
    fin >> N >> M;

    MaximumFlow flow(N, 0, N - 1);
    for (int i = 0; i < M; ++i) {
        int u, v, cap;
        fin >> u >> v >> cap;
        flow.add_edge(u - 1, v - 1, cap);
    }

    fout << flow.maximum_flow();

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