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

using namespace std;

ifstream f("maxflow.in");
ofstream g("maxflow.out");

int n, m, flux_maxim, flux_minim, nod;

vector<vector<int>>vecini;
vector<bool>vizitat;
vector<int>tata;
vector<vector<int>>capacitate;
vector<vector<int>>flux;

int bfs()
{
	queue<int>coada;

	for (int i = 1; i <= n; i++)
		vizitat[i] = tata[i] = 0;

	vizitat[1] = 1;

	coada.push(1);

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

		for (int i = 0; i < vecini[u].size(); i++)
		{
			int v = vecini[u][i];

			if (vizitat[v] || capacitate[u][v] == flux[u][v])
				continue;

			vizitat[v] = 1;

			coada.push(v);

			tata[v] = u;
				
			if (v == n)
				return 1;
		}
	}

	return 0;
}

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

	vecini.resize(n + 1);
	capacitate.resize(n + 1, vector<int>(n + 1, 0));
	flux.resize(n + 1, vector<int>(n + 1, 0));
	tata.resize(n + 1);
	vizitat.resize(n + 1);

	for (int i = 1; i <= m; i++)
	{
		int x, y, z;

		f >> x >> y >> z;
	
		vecini[x].push_back(y);
		vecini[y].push_back(x);

		capacitate[x][y] += z;
	}
	
	while (bfs())
	{
		flux_minim = 99999999;
		
		nod = n;
		
		while (nod != 1)
		{
			if (flux_minim > capacitate[tata[nod]][nod] - flux[tata[nod]][nod])
				flux_minim = capacitate[tata[nod]][nod] - flux[tata[nod]][nod];

			nod = tata[nod];
		}

		nod = n;

		while (nod != 1)
		{
			flux[tata[nod]][nod] += flux_minim;
			flux[nod][tata[nod]] -= flux_minim;

			nod = tata[nod];
		}

		flux_maxim += flux_minim;
	}

	g << flux_maxim;
	
	return 0;
}