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

//*
ifstream  in("maxflow.in");
ofstream out("maxflow.out");
//*/
/*
ifstream  in("input.txt");
ofstream out("output.txt");
ofstream deb("debug.txt");
//*/

struct edge {
    int u, v;
    long long cost, flow;
};

const int MAX_N = 105;
const long long INF = int(1e5) + 10;
int n, m,
    s, t,
    mQueue[MAX_N], qHead, qTail,
    deep[MAX_N], lastAccess[MAX_N];
std::vector <int> G[MAX_N];
std::vector <edge> E;

void input() {
    in>>n>>m;

    edge temp = {0, 0, 0, 0};
    for (int i = 0; i < m; i++) {
        in>>temp.u>>temp.v>>temp.cost;
        temp.u--; temp.v--;

        G[temp.u].push_back ((int) E.size()); //ptr on edge
        E.push_back(temp);
        temp.cost = 0;
        G[temp.v].push_back ((int) E.size()); //ptr on edge
        E.push_back(temp);
    }
    s = 1 - 1; t = n - 1;
}

bool bfs() {
    qHead = 0; qTail = 0;
    mQueue[qTail++] = s;

    memset (deep, -1, n * sizeof deep[0]);
    deep[s] = 0;

    int from, to, idEdge;
    while (qHead < qTail && deep[t] == -1) {
        from = mQueue[qHead++];
        for (int i = 0; i < G[from].size(); ++i) {
            idEdge = G[from][i];
            to = E[idEdge].v;
            if (deep[to] == -1 && E[idEdge].flow < E[idEdge].cost) {
                mQueue[qTail++] = to;
                deep[to] = deep[from] + 1;
            }
        }
    }
    return deep[t] != -1;
}

long long dfs (int from, long long flow) {
    if (!flow || from == t) { return flow;}

    int idEdge, to;
    long long pushed;
    for (; lastAccess[from] < (int)G[from].size(); ++lastAccess[from]) {
        idEdge = G[from][ lastAccess[from] ];
        to = E[idEdge].v;

        if (deep[to] != deep[from] + 1) { continue; }

        pushed = dfs (to, min (flow, E[idEdge].cost - E[idEdge].flow));
        if (pushed) {
            E[idEdge].flow += pushed;
            E[idEdge^1].flow -= pushed;
            return pushed;
        }
    }
    return 0;
}

long long solve() {
    long long maxflow = 0, pushed;

    while (bfs()) {
        memset (lastAccess, 0, n * sizeof lastAccess[0]);
        while (pushed = dfs (s, INF)) { maxflow += pushed; }
    }

    return maxflow;
}

int main() {
    input();
    out<<solve();
    return 0;
}