#include <fstream>
#include <cassert>
#include <vector>
#include <cstring>

using namespace std;

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

const int N = 1009;

vector < int > g[N];
int cap[N][N];

namespace FLUX {
    int n, s, t;
    int dq[N];
    bool viz[N];
    int tata[N];
    int f[N][N];

    bool bfs() {
        memset(viz, 0, sizeof viz);
        int st(0), dr(-1);
        dq[++dr] = s;

        while (st <= dr) {
            int x = dq[st++];
            if (x == t)
                continue;

            for (int i : g[x]) {
                if (viz[i] == 0 && cap[x][i] - f[x][i] > 0) {
                    tata[i] = x;
                    viz[i] = 1;
                    dq[++dr] = i;
                }
            }
        }

        return viz[t];
    }

    int augument() {
        int mn((int)2e9 + 7);
        int nod = t;

        while (nod != s) {
            mn = min(mn, cap[tata[nod]][nod] - f[tata[nod]][nod]);
            nod = tata[nod];
        }

        if (nm == 0)
            return 0;
        nod = t;

        while (nod != s) {
            f[tata[nod]][nod] += mn;
            f[nod][tata[nod]] -= mn;
            nod = tata[nod];
        }

        return mn;
    }

    int flux(const int &_n, const int &_s, const int &_t) {
        n = _n;
        s = _s;
        t = _t;

        int ans(0);
        while (bfs()) {
            for (int i : g[t]) {
                if (cap[i][t] - f[i][t] > 0 && viz[i]) {
                    tata[t] = i;
                    ans += augument();
                }
            }
        }

        return ans;
    }
}

int main() {
    int n, m, x, y, z;
    cin >> n >> m;

    while (m--) {
        cin >> x >> y >> z;
        cap[x][y] += z;
        g[x].push_back(y);
        g[y].push_back(x);
    }

    cout << FLUX::flux(n, 1, n);
    return 0;
}