#include <iostream>
#include <fstream>
#include <vector>
#include <deque>
#include <cstring>
#define dMAX (1 << 10)
#define INF  (1 << 25)

using namespace std;

typedef pair<int, int> pi;

int n, m;
int x, y, c;
int maxFlow, newC, flow;
vector<int> graf[dMAX + 2];
int capacity[dMAX + 2][dMAX + 2];
int curFlow[dMAX + 2][dMAX + 2];
int parent[dMAX + 2], cnodeCapacity[dMAX + 2];

deque<int> myDeque;
int pVerif, newV;

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

int BFS() {
    int i, j;
    myDeque.clear();
    memset(parent, -1, sizeof(parent));
    memset(cnodeCapacity, 0, sizeof(cnodeCapacity));
    parent[1] = -2;
    cnodeCapacity[1] = INF;
    myDeque.push_back(1);
    while (!myDeque.empty()) {
        pVerif = myDeque.front();
        myDeque.pop_front();
        for (i = 0; i < graf[pVerif].size(); i++) {
            newV = graf[pVerif][i];
            if (parent[newV] == -1) {
                newC = capacity[pVerif][newV] - curFlow[pVerif][newV];
                if (newC > 0) {
                    parent[newV] = pVerif;
                    cnodeCapacity[newV] = min(cnodeCapacity[pVerif], newC);
                    if (newV == n) return cnodeCapacity[n];
                    myDeque.push_back(newV);
                }
            }
        }
    }
    return 0;
}

int MaximumFlow() {
    int mFlow = 0;
    while (true) {
        flow = BFS();
        if (flow == 0) break;
        mFlow += flow;
        pVerif = n;
        while (pVerif != 1) {
            newV = parent[pVerif];
            curFlow[pVerif][newV] -= flow;
            curFlow[newV][pVerif] += flow;
            pVerif = newV;
        }
    }
    return mFlow;
}

int main()
{
    int i, j;
    fin >> n >> m;
    for (i = 1; i <= m; i++) {
        fin >> x >> y >> c;
        capacity[x][y] = c;
        graf[x].push_back(y);
        graf[y].push_back(x);
    }
    maxFlow = MaximumFlow();
    fout << maxFlow;
    return 0;
}