#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <fstream>
using namespace std;

int n, m;

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

struct edge
{
	int to, cap, rev;

	edge () {}
	edge(int _to, int _cap,int _rev): to(_to), cap(_cap), rev(_rev){}
};

vector<vector<edge>> g;
vector<int> level;
vector<int> iter;

inline void add_edge(int u, int v, int cap)
{
	g[u].push_back(edge(v, cap, g[v].size()));
	g[v].push_back(edge(u, 0, g[u].size() - 1));
}

inline bool bfs()
{
	queue<int> q;
	level.assign(n, -1);

	q.push(0);
	level[0] = 0;

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

		for (auto &edge : g[u])
		{
			if (level[edge.to] == -1 && edge.cap > 0)
			{
				level[edge.to] = level[u] + 1;
				q.push(edge.to);
			}
		}
	}

	return level[n - 1] != -1;
}

long long dfs(int u, int flow)
{
	if (u == n - 1)
		return flow;

	for (int &i = iter[u]; i < g[u].size(); ++i)
	{
		auto &edge = g[u][i];
		if (edge.cap > 0 && level[edge.to] == level[u] + 1)
		{
			int d = dfs(edge.to, min(flow, edge.cap));
			if (d > 0)
			{
				edge.cap -= d;
				g[edge.to][edge.rev].cap += d;
				return d;
			}
		}
	}

	return 0;
}

inline long long dinic_flow()
{
	long long max_flow(0);
	while (bfs())
	{
		iter.assign(n + 1, 0);
		int flow;
		while ((flow = dfs(0, 1e9)) > 0)
		{
			max_flow += flow;
		}
	}

	return max_flow;
}

int main()
{
	//ios_base::sync_with_stdio(false);
	fin >> n >> m;
	level.assign(n, -1);
	g.assign(n, vector<edge> ());

	for (int i = 0; i < m; i++)
	{
		int u, v, c;
		fin >> u >> v >> c;
		--u, --v;
		add_edge(u, v, c);
	}

	fout << dinic_flow() << endl;
	return 0;
}