#include <fstream>
#include <queue>
#include <vector>
#define nmax 1024

using namespace std;

int N, M, A, K;
queue<int> Q;
vector<int> G[nmax];
int C[nmax][nmax], F[nmax][nmax];
vector<int> Vis, Father;

void read()
{
	int x, y, c;

	ifstream fin("maxflow.in");
	fin >> N >> M;
	
	for (int i = 0; i < M; ++i)
	{
		fin >> x >> y >> c;
		C[x][y] = c;
		G[x].push_back(y);
		G[y].push_back(x);
	}
	
	fin.close();
}

void clear()
{
   std::queue<int> R;
   std::swap(Q, R);
}

int flow()
{
	clear();
	Q.push(1);
	Vis[1] = ++K;

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

		for (vector<int>::iterator i = G[u].begin(); i != G[u].end(); ++i)
		{
			int v = *i;

			if (Vis[v] < K)
			{
				if (C[u][v] > F[u][v])
				{
					Vis[v] = K;
					Father[v] = u;

					if (v < N)
						Q.push(v);
				}
			}
		}

		Q.pop();
	}

	if (Vis[N] < K)
		return 0;

	int a = 0;

	for (vector<int>::iterator i = G[N].begin(); i != G[N].end(); ++i)
	{
		int n = *i, f;

		if (Vis[n] == K && C[n][N] > F[n][N])
		{
			int f = C[n][N] - F[n][N], v;
			
			for (v = n; v > 1 && f > 0; v = Father[v])
			{
				int u = Father[v];
				f = min(f, C[u][v] - F[u][v]);
			}

			if (f > 0)
			{
				for (Father[N] = n, v = N; v > 1; v = Father[v])
				{
					int u = Father[v];
					F[u][v] += f;
					F[v][u] -= f;
				}

				a += f;
			}
		}
	}
	
	return a;
}

void solve()
{
	Vis.assign(N + 1, 0);
	Father.assign(N + 1, 0);

	int a;

	while (a = flow())
		A += a;
}

void write()
{
	ofstream fout("maxflow.out");
	fout << A << '\n';
	fout.close();
}

int main()
{
	read();
	solve();
	write();
	return 0;
}