#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;

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

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

	queue<int>coada;

	vizitat[1] = 1;

	coada.push(1);

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

		if (u == n)
			continue;

		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;
		}
	}

	return vizitat[n];
}

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

	vecini.resize(n + 1);
	vizitat.resize(n + 1);
	tata.resize(n + 1);
	capacitate.resize(n + 1, vector<int>(n + 1, 0));
	flux.resize(n + 1, vector<int>(n + 1, 0));
	
	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())
	{
		for (int i = 0; i < vecini[n].size(); i++)
		{
			int nod = vecini[n][i];

			if (!vizitat[nod] || capacitate[nod][n] == flux[nod][n])
				continue;

			tata[n] = nod;

			flux_minim = 999999;

			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];
			}

			if (flux_minim == 0)
				continue;
			
			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;
}