#include <cstdio>
#include <queue>
#include <vector>
#include <cstring>

using namespace std;

vector <long> G [1001];
long f [1001][1001], c [1001][1001];
long T [1001];
const long INF = 2000000000;
bool viz [1001];

void read (long &V, long &E) {
    long i, u, v, c1;
    scanf ("%ld%ld", &V, &E);
    for (i = 1; i <= E; i ++) {
        scanf ("%ld%ld%ld", &u, &v, &c1);
        c [u][v] = c1;
        G [u].push_back (v);
        G [v].push_back (u);
    }
}

bool bfs (const long &s, const long &t) {
    long x;
    queue <long> q;
    vector <long> :: iterator it;

    memset (viz, 0, sizeof (viz));
    memset (T, 0, sizeof (T));

    q.push (s); viz [s] = true;
    while (!q.empty ()) {
        x = q.front ();
        for (it = G [x].begin (); it != G [x].end (); ++ it)
            if (!viz [*it])
                if (c [x][*it] - f [x][*it] > 0) {
                    q.push (*it);
                    T [*it] = x;
                    viz [*it] = true;
                }
        q.pop ();
    }
    return viz [t];
}

long maxFlux (long s, long t) {
    long min, flow = 0, i, j;
    while (bfs (s, t) == true)
        for (j = 1; j <= t; j ++)
            if (viz [j]) {
                min = c [j][t] - f [j][t];
                for (i = j; i != s; i = T [i])
                    if (c [T [i]][i] - f [T [i]][i] < min)
                        min = c [T [i]][i] - f [T [i]][i];
                if (min == 0)
                    continue;
                for (i = t; i != s; i = T [i]) {
                    f [T [i]][i] += min;
                    f [i][T [i]] += min;
                }
                flow += min;
            }
    return flow;
}

void solve (const long &V, const long &E) {
    printf ("%ld\n", maxFlux (1, V));
}

int main () {
    long V, E;

    freopen ("maxflow.in", "r", stdin);
    freopen ("maxflow.out", "w", stdout);

    read (V, E);
    solve (V, E);
    return 0;
}