#include <bits/stdc++.h>
using namespace std;

class Graph{
public:
    const int N;
    vector<vector<int>> neighbors;
    vector<vector<int>> capacity;

public:
    Graph(const int& N): N(N){
        neighbors.resize(N);
        capacity.assign(N, vector<int>(N));
    }

    void addEdge(int x, int y, int c){
        neighbors[x].push_back(y);
        neighbors[y].push_back(x);
        capacity[x][y] = c;
    }
};

class FordFulkerson{
private:
    const Graph& G;
    const int N;
    const int SRC;
    const int DEST;
    vector<vector<int>> f;
    vector<int> visTokenOf;
    int visToken;

    int augmentingPath(int node, int minDelta){
        if(visTokenOf[node] == visToken){
            return 0;
        }
        
        visTokenOf[node] = visToken;
        
        if(node == DEST){
            return minDelta;
        }

        for(int nextNode: G.neighbors[node]){
            int remainingCapacity = G.capacity[node][nextNode] - f[node][nextNode];
            if(remainingCapacity > 0){
                int delta = augmentingPath(nextNode, min(minDelta, remainingCapacity));
                if(delta > 0){
                    f[node][nextNode] += delta;
                    f[nextNode][node] -= delta;
                    return delta;
                }
            }
        }

        return 0;
    }

public:
    FordFulkerson(const Graph& G, const int& SRC, const int& DEST):
                  G(G), N(G.N), SRC(SRC), DEST(DEST){
        f.assign(N, vector<int>(N));
        visTokenOf.resize(N);
    }

    int computeMaxFlow(){
        visToken = 0;
        fill(visTokenOf.begin(), visTokenOf.end(), 0);

        int maxFlow = 0;
        bool containsAugmentingPath = true;
        while(containsAugmentingPath){
            visToken += 1;
            int delta = augmentingPath(SRC, INT_MAX);
            if(delta > 0){
                maxFlow += delta;
            }else{
                containsAugmentingPath = false;
            }
        }

        return maxFlow;
    }
};

int main(){
    ifstream cin("maxflow.in");
    ofstream cout("maxflow.out");

    int N, M;
    cin >> N >> M;

    Graph G(N);
    int x, y, c;
    for(int i = 0; i < M; ++i){
        cin >> x >> y >> c;
        G.addEdge(x - 1, y - 1, c);
    }

    cout << FordFulkerson(G, 0, N - 1).computeMaxFlow();

    cin.close();
    cout.close();
    return 0;
}