#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <utility>
#include <queue>

int n, m;
int rGraph[1001][1001];
std::vector< std::pair<int, int> > graph[1001];

bool BFS(int s, int t, int parent[]){

    std::queue< int > q;
    for(int i = 0; i <= n; ++i)
        parent[i] = 0;
    parent[s] = -1;
    q.push(s);

    while (!q.empty()){
        int u = q.front();
        q.pop();
        for (auto& edge : graph[u]){
            int v = edge.first;
            if (!parent[v] && rGraph[u][v] > 0){
                q.push(v);
                parent[v] = u;
            }
        }
    }
    return parent[t] != 0;
}

int FordFulkerson(){

    int u, v;
    int parent[1000], maxFlow = 0;

    while(BFS(1, n, parent)){

        int pathFlow = (1 << 31) - 1;

        for(v = n; v != 1; v = parent[v]){
            u = parent[v];
            pathFlow = std::min(pathFlow, rGraph[u][v]);
        }

        for(v = n; v != 1; v = parent[v]){
            u = parent[v];
            rGraph[u][v] -= pathFlow;
            rGraph[v][u] += pathFlow;
        }
        maxFlow += pathFlow;
    }
    return maxFlow;
}

int main(){

    std::ifstream f("maxflow.in");
    std::ofstream g("maxflow.out");
    int x, y, c;

    f >> n >> m;
    while(m--){
        f >> x >> y >> c;
        graph[x].push_back({y, c});
        rGraph[x][y] = c;
    }

    g << FordFulkerson() << '\n';
}