# include <fstream>
# include <vector>
# include <bitset>
# include <queue>

using namespace std;

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

const int MAX = 1024;
const int INF = (1<<30);

typedef int matrice[MAX][MAX];

bitset<MAX> viz;
vector<int> L[MAX], t(MAX);
queue<int> q;
matrice c, f;
int n, m;

bool BFS() {
    bool found = 0;
    int nod, vec;
    vector<int>::iterator i;

    for (int i=2; i<=n; ++i)
        viz[i] = 0;

    q.push(1);
    viz[1] = 1;

    while (!q.empty()) {
        nod = q.front();
        for (i = L[nod].begin(); i != L[nod].end(); ++i) {
            vec = *i;
            if (c[nod][vec] > f[nod][vec] && viz[vec] == 0) {
                viz[vec] = 1;
                q.push(vec);
                t[vec] = nod;
                if (vec == n)
                    found = 1;
            }
        }
        q.pop();
    }

    return found;
}


int main() {
    int x, y, z, flow, nod, fmin;
    vector<int>::iterator i;

    fin >> n >> m;
    for (int i=1; i<=m; ++i) {
        fin >> x >> y >> z;
        c[x][y] += z;
        c[y][x] = 0;
        L[x].push_back(y);
        L[y].push_back(x);
    }

    flow = 0;
    while (BFS()) {
        for (i = L[n].begin(); i != L[n].end(); ++i) {
            nod = *i;

            if (c[nod][n] > f[nod][n] && viz[nod] == 1) {
                fmin = c[nod][n] - f[nod][n];

                for (nod = n; nod != 1; nod = t[nod])
                    fmin = min(fmin, c[ t[nod] ][nod] - f[ t[nod] ][nod]);

                flow += fmin;

                f[nod][n] += fmin;
                f[n][nod] -= fmin;

                for (nod = n; nod != 1; nod = t[nod]) {
                    f[ t[nod] ][nod] += fmin;
                    f[nod][ t[nod] ] -= fmin;
                }
            }
        }
    }
    fout << flow;
    return 0;
}