#include <climits>
#include <queue>
#include <vector>
#include <cstring>
#include <fstream>

using namespace std;

ifstream fin("maxflow.in");
ofstream fout("maxflow.out");

#define N_MAX 1001
#define INFINITY INT_MAX

int N, M, max_flux = 0;
bool visited[N_MAX];
vector<int> neighbors[N_MAX];
int parent[N_MAX], flux[N_MAX][N_MAX], capacity[N_MAX][N_MAX];

bool BFS() {
	int node;
	queue<int> queue;

	memset(visited, false, N_MAX * sizeof(visited[0]));
	queue.push(1);

	while (!queue.empty()) {
		node = queue.front();
		queue.pop();

		for (auto neigh : neighbors[node]) {
			if (!visited[neigh] && capacity[node][neigh] - flux[node][neigh] > 0) {
				queue.push(neigh);
				parent[neigh] = node;
				visited[neigh] = true;
			}
		}
	}

	return visited[N];
}

int main() {
	int x, y, c, node, min_flux;

	fin >> N >> M;

	for (int i = 0; i < M; ++i) {
		fin >> x >> y >> c;

		capacity[x][y] = c;
		neighbors[x].push_back(y);
		neighbors[y].push_back(x);
	}

	for (max_flux = 0; BFS();) {
		min_flux = INFINITY;

		for (node = N; node != 1; node = parent[node]) {
			min_flux = min(min_flux, capacity[parent[node]][node] - flux[parent[node]][node]);
		}

		for (node = N; node != 1; node = parent[node]) {
			flux[parent[node]][node] += min_flux;
			flux[node][parent[node]] -= min_flux;
		}

		max_flux += min_flux; 
	}

	fout << max_flux;

	return 0;
}