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

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

// Flux maxim

const int NMax = 1e3 + 10;

vector< vector< int > > G;
int capacities[NMax][NMax], flux[NMax][NMax];
vector< bool > viz;
vector< int > tata;

bool BFS(int startNode, int finalNode) {
    fill(viz.begin(), viz.end(), false); fill(tata.begin(), tata.end(), -1);

    queue< int > q;
    q.push(startNode);
    viz[startNode] = true;

    while(!q.empty()) {
        int tempNode = q.front(); q.pop();

        for(auto vecin: G[tempNode]) {
            if(!viz[vecin] && capacities[tempNode][vecin] - flux[tempNode][vecin] > 0) {
                tata[vecin] = tempNode;

                if(vecin == finalNode) {
                    return true;
                }

                viz[vecin] = true;
                q.push(vecin);
            }
        }
    }

    return false;
}

void EdmondKarp(int startNode, int finalNode) {
    int maxFlux = 0;

    while(BFS(startNode, finalNode) == true) {
        int tempNode = finalNode, minFlux = 1e9;

        while(tempNode != startNode) {
            minFlux = min(minFlux, capacities[tata[tempNode]][tempNode] - flux[tata[tempNode]][tempNode]);
            tempNode = tata[tempNode];
        }

        maxFlux += minFlux;

        tempNode = finalNode;
        while(tempNode != startNode) {
            flux[tata[tempNode]][tempNode] += minFlux;
            flux[tempNode][tata[tempNode]] -= minFlux;
            tempNode = tata[tempNode];
        }
    }
    
    out << maxFlux << "\n";
}

int main() {

    int n, m; in >> n >> m;
    
    G.resize(n + 1); viz.resize(n + 1); tata.resize(n + 1);
    for(int i = 1; i <= m; ++i) {
        int x, y, capacity; in >> x >> y >> capacity;
        G[x].push_back(y);
        G[y].push_back(x);
        capacities[x][y] = capacity;
    }

    EdmondKarp(1, n);

    return 0;
}