//BEGIN CUT
#include <algorithm>
#include <climits>
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;

//END CUT
const size_t MAXN = 1024;
vector<bool> visited(MAXN);
vector<int> graph[MAXN];
int parent[MAXN], bf_queue[MAXN],
	capacity[MAXN][MAXN], flow[MAXN][MAXN];

bool find_path(int start, int destination) {
	fill(visited.begin(), visited.end(), false);
	visited[start] = true;
	int queue_sz = 1;
	bf_queue[0] = start;

	for (int i = 0; i < queue_sz; ++i)
	{
		int u = bf_queue[i];
		if (u == destination) continue;
		for (int &v : graph[u])
		{
			if (capacity[u][v] == flow[u][v] || visited[v])
				continue;
			visited[v] = true;
			bf_queue[queue_sz++] = v;
			parent[v] = u;
		}
	}

	return visited[destination];
}

int max_flow (int source, int sink)
{
	int maxflow = 0;

	while (find_path(source, sink))
		for (int &v : graph[sink])
		{
			if (capacity[v][sink] == flow[v][sink] || !visited[v])
				continue;
			parent[sink] = v;

			int bottleneck = INT_MAX;
			for (int u = sink; u != source; u = parent[u])
				bottleneck = min(bottleneck,
						capacity[parent[u]][u] - flow[parent[u]][u]);
			if (bottleneck == 0) continue;

			for (int u = sink; u != source; u = parent[u])
			{
				flow[parent[u]][u] += bottleneck;
				flow[u][parent[u]] -= bottleneck;
			}

			maxflow += bottleneck;
		}

	return maxflow;
}
//BEGIN CUT
int main()
{
	ifstream fin("maxflow.in");
	ofstream fout("maxflow.out");

	int nr_vertices, nr_edges;
	fin >> nr_vertices >> nr_edges;
	for (; nr_edges; --nr_edges)
	{
		int u, v, c;
		fin >> u >> v >> c;
		capacity[u][v] = c;
		graph[u].push_back(v);
		graph[v].push_back(u);
	}

	fout << max_flow(1, nr_vertices) << endl;

	fout.close();
	return 0;
}
//END CUT