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

using namespace std;

const int NMAX = 1000;
const int INF = (1 << 30);
int N, M;
struct Edge {
    int u, v, flow, cap;
};
vector <Edge> edges;
vector <pair <int, int>> graph[1 + NMAX];

void AddEdge(int u, int v, int flow, int cap) {
    graph[u].push_back(make_pair(v, edges.size()));
    edges.push_back({u, v, 0, cap});
    graph[v].push_back(make_pair(u, edges.size()));
    edges.push_back({v, u, 0, 0});
}

int level[1 + NMAX], last[1 + NMAX];

bool bfs() {
    for (int i = 1; i <= N; ++i) {
        level[i] = INF;
    }
    level[1] = 0;
    queue <int> q;
    q.push(1);
    while (!q.empty()) {
        int node = q.front();
        q.pop();
        if (node == N)
            continue;
        for (auto& x : graph[node]) {
            int flow = edges[x.second].flow;
            int cap = edges[x.second].cap;
            if (level[x.first] > level[node] + 1 && flow < cap) {
                level[x.first] = level [node] + 1;
                q.push(x.first);
            }
        }
    }
    return (level[N] != INF);
}

int dfs(int node, int deltaFlow) {
    if (node == N || deltaFlow == 0)
        return deltaFlow;
    else {
        for (int& p = last[node]; p < graph[node].size(); ++p) {
            int ind = graph[node][p].second;
            int nextNode = graph[node][p].first;
            int flow = edges[ind].flow;
            int cap = edges[ind].cap;
            if (level[nextNode] == level[node] + 1 && flow < cap) {
                int currFlow = dfs(nextNode, min(deltaFlow, cap - flow));
                if (currFlow > 0) {
                    edges[ind].flow += currFlow;
                    edges[ind ^ 1].flow -= currFlow;
                    return currFlow;
                }
            }
        }
        return 0;
    }
}

int GetFlow() {
    int maxFlow = 0;
    while (bfs()) {
        for (int i = 1; i <= N; ++i)
            last[i] = 0;
        int deltaFlow = dfs(1, INF);
        while (deltaFlow > 0) {
            maxFlow += deltaFlow;
            deltaFlow = dfs(1, INF);
        }
    }
    return maxFlow;
}

int main() {
    ifstream fin("maxflow.in");
    ofstream fout("maxflow.out");
    fin >> N >> M;
    for (int i = 1; i <= M; ++i) {
        int u, v, cap;
        fin >> u >> v >> cap;
        AddEdge(u, v, 0, cap);
    }
    fout << GetFlow() << "\n";
    fin.close();
    fout.close();
    return 0;
}