#include<bits/stdc++.h>
// #define int long long 
#define x first
#define y second 
using namespace std;

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

class MaxFlow {
    vector<vector<int>> capacity;
    vector<vector<int>> E;
    int nodes, s, t;
    const int INF = 2e9;
public:
    MaxFlow(int _nodes) : s(1), t(_nodes), nodes(_nodes) {
        capacity.assign(nodes + 5, vector<int> (nodes + 5, 0));
        E.resize(nodes + 5);
    }
    void AddEdge(int u, int v, int cap) {
        capacity[u][v] = cap;
        E[u].push_back(v);
        E[v].push_back(u);
    }
    int bfs(vector<int> &par) {
        bool seen_t = false;
        fill(par.begin(), par.end(), -1);
        par[s] = -INF;
        queue<int> Q;
        Q.push(s);
        while(Q.size()) {
            auto cur_node = Q.front();
            Q.pop();
            for(auto it : E[cur_node]) {
                if(capacity[cur_node][it] && par[it] == -1) {
                    if(it == t) {
                        seen_t = true;
                        continue;
                    }
                    par[it] = cur_node;
                    Q.push(it);
                }
            }
        }
        return seen_t;
    }
    int Compute_Flow() {
        int flow = 0, flow_pushed;
        vector<int> par(nodes + 1);
        while(bfs(par)) {
            for(auto it : E[t]) {
                if(par[it] != -1) {
                    int pushed_flow = INF;
                    int cur_node = it;
                    while(cur_node != s) {
                        int prd_node = par[cur_node];
                        pushed_flow = min(pushed_flow, capacity[prd_node][cur_node]);
                        cur_node = prd_node;
                    }
                    cur_node = it;
                    flow += pushed_flow;
                    while(cur_node != s) {
                        int prd_node = par[cur_node];
                        capacity[prd_node][cur_node] -= pushed_flow;
                        capacity[cur_node][prd_node] += pushed_flow;
                        cur_node = prd_node;
                    }
                }
            }
        }
        return flow;
    }
};

int n, m;

int32_t main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    in >> n >> m;
    MaxFlow Flow(n);
    for(int i = 0; i < m; ++i) {
        int u, v, cap;
        in >> u >> v >> cap; 
        Flow.AddEdge(u, v, cap); 
    }
    out << Flow.Compute_Flow() << '\n';
    return 0;
}