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

#include <cstring>
using namespace std;

const int MAX_N = 1002;
const int INF = 0x3f3f3f3f;

int N, M, sol;
int Capacity[MAX_N][MAX_N], Flow[MAX_N][MAX_N], F[MAX_N];
vector < int > v[MAX_N];
queue < int > Q;

inline bool BFS(int st, int end) {
    memset(F, 0, sizeof(F));
    F[st] = st;
    Q.push(st);
    while(!Q.empty()) {
        int x = Q.front();
        Q.pop();
        if(x == end)
            continue;
        for(size_t i = 0; i < v[x].size(); ++i) {
            int y = v[x][i];
            if(F[y] || Capacity[x][y] <= Flow[x][y])
                continue;
            F[y] = x, Q.push(y);
        }
    }

    return (F[end] != 0);
}

int main() {
    ifstream f("maxflow.in");
    ofstream g("maxflow.out");

    f >> N >> M;
    for(int i = 1, x, y, c; i <= M; ++i) {
        f >> x >> y >> c;
        v[x].push_back(y), v[y].push_back(x);
        Capacity[x][y] += c;
    }

    while(BFS(1, N)) {
        for(size_t i = 0; i < v[N].size(); ++i) {
            int y = v[N][i];
            if(!F[y] || Capacity[y][N] <= Flow[y][N])
                continue;
            F[N] = y;
            int MinFlow = INF;
            for(int node = N; node != 1; node = F[node])
                MinFlow = min(MinFlow, Capacity[F[node]][node] - Flow[F[node]][node]);
            for(int node = N; node != 1; node = F[node])
                Flow[F[node]][node] += MinFlow, Flow[node][F[node]] = -Flow[F[node]][node];
            sol += MinFlow;
        }
    }

    g << sol << "\n";

    f.close();
    g.close();

    return 0;
}