#include <bits/stdc++.h>
using namespace std;

#define NMAX 1001
#define INF 1e9

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

int cap[NMAX][NMAX], flux[NMAX][NMAX];

vector<int> graf[NMAX];

int source, sink;

inline void addEdge(const int x, const int y, const int c) {

    graf[x].push_back(y);
    graf[y].push_back(x);
    cap[x][y] += c;
}

int tata[NMAX];

int dist[NMAX];

int BFS() {

    for (int i = source; i <= sink; ++i)
        dist[i] = INF;

    queue<int> Q;

    dist[source] = 0;
    Q.push(source);

    while (!Q.empty()) {

        int nod = Q.front();
        Q.pop();

        if (nod == sink)
            break;

        for (auto& adj: graf[nod]) {

            if (dist[adj] > dist[nod] + 1 && flux[nod][adj] < cap[nod][adj]) {

                dist[adj] = dist[nod] = 1;
                tata[adj] = nod;

                Q.push(adj);
            }
        }
    }

    return (dist[sink] != INF);
}

int maxFlow() {

    int ans = 0;

    while (BFS()) {

        for (auto& adj: graf[sink]) {

            int flow = INF;

            if (dist[adj] == INF || cap[adj][sink] == flux[adj][sink])
                continue;

            tata[sink] = adj;

            for (int i = sink; i != source; i = tata[i])
                flow = min(flow, cap[tata[i]][i] - flux[tata[i]][i]);

            if (!flow)
                continue;

            ans += flow;

            for (int i = sink; i != source; i = tata[i]) {
                flux[tata[i]][i] += flow;
                flux[i][tata[i]] -= flow;
            }
        }
    }

    return ans;
}

int main() {

    int N, M;

    fin >> N >> M;

    source = 1;
    sink = N;

    int x, y, c;
    while (M--) {

        fin >> x >> y >> c;

        addEdge(x, y, c);
    }

    fout << maxFlow();

    return 0;
}