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

#define MaxSize 2000
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

int n, m, elem, nod, flux_max, flux_min, firstelem, k, capacitate[MaxSize][MaxSize], flux_curr[MaxSize][MaxSize];
vector<vector < int>> adj, reversed_adj;
vector<int> tata;
vector<bool> viz;
queue<int> que;

int BFS(int node)
{
	while (!que.empty()) que.pop();

	tata.clear();
	tata.resize(n + 1, 0);
	viz.clear();
	viz.resize(n + 1, false);

	que.push(node);
	viz[node] = true;

	while (!que.empty())
	{
		firstelem = que.front();
		que.pop();

		for (auto vec: adj[firstelem])
		{
			if (viz[vec] == false && capacitate[firstelem][vec] > flux_curr[firstelem][vec])
			{
				que.push(vec);
				viz[vec] = true;
				tata[vec] = firstelem;
				if (vec == n) return 1; // aici actualizam lista de vizitati si tati.
			}
		}
	}

	return 0;

}

void flux_update()

{
	for (auto vec: reversed_adj[n]) // mergem pe reversed_adj pentru a putea merge de la destinatie la coada.

		if (capacitate[vec][n] >= flux_curr[vec][n] && viz[vec] == true)
		{
			elem = n;
			tata[n] = vec;
			flux_min = INT_MAX;

			while (elem != 1)
			{
				nod = tata[elem];

				if (nod > 0)
				{
					int ramas = capacitate[nod][elem] - flux_curr[nod][elem];
					if (flux_min > ramas)
						flux_min = ramas; // stabilesc fluxul minim pe care l pot pompa, ducandu ma de la destinatie
						// la inceput, si practic minim-ul dintre maximul fiecaruia este raspunsul.
				}
				else if (flux_min > flux_curr[elem][-nod])
					flux_min = flux_curr[elem][-nod];

				elem = nod;
				if (elem < 0)
					elem = -elem;
			}

			elem = n;

			while (elem != 1)
			{
				nod = tata[elem];

				if (nod > 0)

				{

					flux_curr[nod][elem] += flux_min;
				}
				else

					flux_curr[elem][-nod] -= flux_min;

				elem = nod;
				if (elem < 0)
					elem = -elem;
			}

			flux_max = flux_max + flux_min;
		}
}

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

	adj.resize(n + 1);
	reversed_adj.resize(n + 1);

	tata.resize(n + 1);
	viz.resize(n + 1);
	int cant, a, b;

	for (int i = 0; i < m; i++)
	{
		fin >> a >> b >> cant;
		adj[a].push_back(b);
		reversed_adj[b].push_back(a);
		capacitate[a][b] = cant;
		flux_curr[a][b] = 0;
	}

	flux_max = 0;

	while (BFS(1))
	{
		flux_update();
	}

	fout << flux_max;
	fin.close();
	fout.close();

}