#include <bits/stdc++.h>

using namespace std;

vector<vector<int>> a;
map<pair<int,int>, int> cap;

vector<int> bfs(int s, int t, int n, int c){
    queue<int> q;
    q.push(s);
    vector<int> parent(n + 1);
    parent[s] = -1;
    while(!q.empty()){
        int x = q.front();
        q.pop();

        if(x == n){
            continue;
        }

        for(auto it: a[x]){
            if(!parent[it] && cap[{x, it}] >= c){
                parent[it] = x;
                q.push(it);
            }
        }
    }

    return parent;
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

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

    int n, m;
    in>>n>>m;

    a.resize(n + 1);

    for(int i = 0; i < m; i++){
        int x, y, c;
        in>>x>>y>>c;

        a[x].push_back(y);
        a[y].push_back(x);

        cap[{x, y}] = c;
    }

    int max_flow = 0;
    int delta = (1 << 20);
    while(delta){

        bool found = 1;
        while(found){
            vector<int> bfs_tree = bfs(1, n, n, delta);

            found = 0;
            for(auto it: a[n]){

                if(!bfs_tree[it] || cap[{it, n}] < delta){
                    continue;
                }
                found = 1;

                int bottleneck = INT_MAX;
                for(int i = it, prev = n; i != -1; prev = i, i = bfs_tree[i]){
                    bottleneck = min(bottleneck, cap[{i, prev}]);
                }

                if(!bottleneck){
                    continue;
                }

                for(int i = it, prev = n; i != -1; prev = i, i = bfs_tree[i]){
                    cap[{i, prev}] -= bottleneck;
                    cap[{prev, i}] += bottleneck;
                }

                max_flow += bottleneck;
            }

        }

        delta >>= 1;
    }

    out<<max_flow;
    return 0;
}