#include <bits/stdc++.h>

using namespace std;

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

const int NMAX = 1000;
const int INF = 1e9;

struct Edge {
	int u, v, cap, flow;
};

int n, m;
vector<Edge> edges;
vector<int> adj[NMAX + 1];
int level[NMAX + 1], ptr[NMAX + 1];

void addEdge(int u, int v, int cap, int flow = 0) {
	int m = edges.size();
	edges.push_back({u, v, cap, flow});
	edges.push_back({v, u, 0, 0});

	adj[u].push_back(m);
	adj[v].push_back(m + 1);
}

bool bfs(int u = 1) {
	memset(level, 0, sizeof(level));
	queue<int> q;
	q.push(u);
	level[u] = 1;

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

		for(const auto &it: adj[u]) {
			int v = edges[it].v;
			int cap = edges[it].cap;
			int flow  = edges[it].flow;

			if(level[v] == 0 && cap - flow > 0) {
				q.push(v);
				level[v] = level[u] + 1;
			}
		}
	}

	return level[n] != 0;
}

int dfs(int u = 1, int pushed = INF) {
	if(pushed == 0) {
		return 0;
	}

	if(u == n) {
		return pushed;
	}

	for(int &i = ptr[u]; i < (int) adj[u].size(); i++) {
		int it = adj[u][i];
		int v = edges[it].v;
		int cap = edges[it].cap;
		int flow = edges[it].flow;

		if(level[v] == level[u] + 1 && cap - flow > 0) {
			int pushinP = dfs(v, min(pushed, cap - flow));

			if(pushinP > 0) {
				edges[it].flow += pushinP;
				edges[it ^ 1].flow -= pushinP;

				return pushinP;
			}
		}
	}

	return 0;
}

int main() {
	fin >> n >> m;

	for(int i = 1; i <= m; i++) {
		int u, v, cap;
		fin >> u >> v >> cap;

		addEdge(u, v, cap);
	}

	int ans = 0;

	while(bfs()) {
		memset(ptr, 0, sizeof(ptr));

		int maxFlow = 0;

		while((maxFlow = dfs()) > 0) {
			ans += maxFlow;
		}
	}

	fout << ans << '\n';
	return 0;
}