#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
    
const int INF = 1e9;
    
struct Flow {
    struct Edge {
        int u, v, cap;
    };
    
    vector<vector<int>> g;
    vector<Edge> e;
    vector<int> dist;
    
    Flow(int n) {
        g.resize(n + 1);
        dist.resize(n + 1);
    }
    
    void add_edge(int u, int v, int cap) {
        g[u].push_back(e.size());
        e.push_back({u, v, cap});
        g[v].push_back(e.size());
        e.push_back({v, u, 0});
    }
    
    bool can_bfs(int S, int T) {
        queue<int> q;
        for (int i = 0; i < dist.size(); ++i) dist[i] = INF;
        dist[S] = 0;
        q.push(S);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (auto id : g[u]) {
                auto [uu, v, cap] = e[id];
                if (cap != 0 && dist[u] + 1 < dist[v]) {
                    dist[v] = dist[u] + 1;
                    q.push(v);
                }
            }
        }
        return dist[T] != INF;
    }
    
    int push_flow(int u, int T, int F) {
        if (F == 0 || u == T) return F;
        int ret = 0;
        for (auto id : g[u]) {
            auto [uu, v, cap] = e[id];
            if (dist[u] + 1 == dist[v]) {
                int push = push_flow(v, T, min(F, cap));
                F -= push;
                ret += push;
                e[id].cap -= push;
                e[id ^ 1].cap += push;
            }
        }
        return ret;
    }
    
    int max_flow(int S, int T) {
        int ret = 0;
        while (can_bfs(S, T)) {
            ret += push_flow(S, T, INF);
        }
        return ret;
    }
};
 
int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    freopen("maxflow.in", "r", stdin);
    freopen("maxflow.out", "w", stdout);
    int n, m;
    cin >> n >> m;
    Flow f(n);
    for (int i = 0; i < m; ++i) {
        int u, v, c;
        cin >> u >> v >> c;
        f.add_edge(u, v, c);
    }
    cout << f.max_flow(1, n) << "\n";
    return 0;
}