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

#define TASK "maxflow"
#define cin ___cin___
#define cout ___cout___

ifstream cin(TASK ".in");
ofstream cout(TASK ".out");

struct edge
{
	int v, to, flow, cap;

	int go(int x) { return x == v ? to : v; }

	edge(int v, int to, int flow, int cap)
		: v(v), to(to), flow(flow), cap(cap) {}
};

struct graph
{
	vector <edge> e;
	vector <vector <int> > g;
	int s = 0;
	int t;

	int add_v() {
		int v = (int) g.size();
		g.emplace_back();
		return t = v;
	}

	void add_edge(int v, int to, int cap) {
		g[v].push_back((int)e.size());
		e.emplace_back(v, to, 0, cap);
		g[to].push_back((int)e.size());
		e.emplace_back(to, v, 0, 0);
	}

	vector <int> d;
	bool bfs() {
		d.assign(t + 1, -1);
		queue <int> q;
		q.push(s);
		d[s] = 0;

		while (!q.empty()) {
			int v = q.front();
			q.pop();

			for (int id : g[v]) {
				int to = e[id].go(v);
				if (d[to] == -1 && e[id].flow < e[id].cap) {
					d[to] = d[v] + 1;
					q.push(to);
				}
			}
		}

		return d[t] != -1;
	}

	vector <int> ptr;
	int dfs(int v, int flow = (int)1e9) {
		if (flow == 0 || v == t) return flow;
		for (int& i = ptr[v]; i < (int)g[v].size(); i++) {
			edge& ed = e[g[v][i]];
			int to = ed.go(v);
			if (d[v] + 1 == d[to]) {
				int pushed = dfs(to, min(flow, ed.cap - ed.flow));
				if (pushed) {
					ed.flow += pushed;
					e[g[v][i] ^ 1].cap -= pushed;
					return pushed;
				}
			}
		}

		return 0;
	}

	int dinic() {
		int ans = 0;
		while (bfs()) {
			ptr.assign(t + 1, 0);
			while (int x = dfs(0)) ans += x;
		}
		return ans;
	}
};

void solve()
{
	int n, m;
	cin >> n >> m;
	graph g;
	for (int i = 0; i < n; i++) g.add_v();

	for (int i = 0; i < m; i++) {
		int u, v, cap;
		cin >> u >> v >> cap;
		--u; --v;
		g.add_edge(u, v, cap);
	}

	cout << g.dinic() << endl;
}

int main()
{
	solve();
	return 0;
}