#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <deque>
#include <queue>
#define flow first
#define capacity second
#define dMAX (1 << 10)
#define INF  (1 << 10)

using namespace std;

int n, m;
int x, y, c;
int u, pVerif, newV;
int fmin, maxFlow;

pair<int, int> matrix[dMAX + 2][dMAX + 2];

vector<int> graf[dMAX + 2];
int father[dMAX + 2];

deque<int> myDeque;
int viz[dMAX + 2];

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

bool BFS() {
    memset(viz, 0, sizeof(viz));
    viz[1] = true;
    myDeque.clear();
    myDeque.push_back(1);
    while (!myDeque.empty()) {
        pVerif = myDeque.front();
        myDeque.pop_front();
        if (pVerif == n) return true;
        for (u = 0; u < graf[pVerif].size(); u++) {
            newV = graf[pVerif][u];
            if (matrix[pVerif][newV].first == matrix[pVerif][newV].second || viz[newV]) continue;
            viz[newV] = true;
            myDeque.push_back(newV);
            father[newV] = pVerif;
        }
    }
    return false;
}

int main()
{
    int i, j;
    fin >> n >> m;
    for (i = 1; i <= m; i++) {
        fin >> x >> y >> c;
        matrix[x][y].capacity = c;

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

    }
    maxFlow = 0;
    while (BFS()) {
        for (i = 0; i < graf[n].size(); i++) {
            fmin = INF;
            pVerif = graf[n][i];
            if (matrix[pVerif][n].flow == matrix[pVerif][n].capacity || !viz[pVerif]) continue;
            for (j = n; j != 1; j = father[j]) fmin = min(fmin, matrix[ father[j] ][j].capacity - matrix[ father[j] ][j].flow);
            for (j = n; j != 1; j = father[j]) {
                matrix[ father[j] ][j].flow += fmin;
                matrix[j][ father[j] ].flow -= fmin;
            }
            maxFlow += fmin;
        }

    }

    fout << maxFlow;

    return 0;
}