// http://infoarena.ro/problema/capacity
#include <fstream>
#include <vector>
#include <queue>
using namespace std;

#define maxSize 1001
#define INFINITY 0x3f3f3f3f
#define source 1

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

int destination,edges;
bool visit[maxSize];
int father[maxSize];
int capacity[maxSize][maxSize];	// capacitatea muchiei
int currentFlow[maxSize][maxSize];
vector<int> graph[maxSize];

bool breadthFirst();

int main() {
	in >> destination >> edges;

	int from,to,flow;
	for(int i=1;i<=edges;i++) {
		in >> from >> to >> flow;
		capacity[from][to] = flow;

		graph[from].push_back(to);
		graph[to].push_back(from);
	}

	int maxFlow = 0;
	vector<int>::iterator it,end;

	// cat timp gasim drumuri de ameliorare
	while(breadthFirst()) {
		end = graph[destination].end();

		// parcurgem drumurile invers de la 
		// nodurile vecine destinatiei la sursa
		for(it=graph[destination].begin();it!=end;++it)
			// daca nodul a fost vizitat si capacitatea
			// muchie este diferita de fluxul actual
			if(visit[*it] && capacity[*it][destination] != currentFlow[*it][destination]) {
				int node = *it;
				int minFlow = INFINITY;

				father[destination] = node;

				// calculam valoarea minima cu care putem mari
				// fluxul pe acest drum, aceasta fiind valoarea
				// minima cu care poate fi marit fluxul asociat
				// fiecarei muchii care se afla pe drumul gasit
				for(node=destination;node!=source;node=father[node])
					minFlow = min(minFlow,capacity[father[node]][node] - currentFlow[father[node]][node]);

				if(minFlow) {
					for(node=destination;node!=source;node=father[node]) {
						currentFlow[father[node]][node] += minFlow;
						currentFlow[node][father[node]] -= minFlow;
					}

					maxFlow += minFlow;
				}
			}
	}

	out << maxFlow << "\n";

	in.close();
	out.close();

	return (0);
}

bool breadthFirst() {
	memset(visit,false,sizeof(visit));
	visit[source] = true;

	int node;
	vector<int>::iterator it,end;

	queue<int> myQueue;
	myQueue.push(source);

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

		if(node == destination)
			continue;

		end = graph[node].end();
		for(it=graph[node].begin();it!=end;++it)
			// daca nodul nu a fost vizitat si fluxul
			// asociat pana in acest moment este
			// strict mai mic decat capacitatea muchiei
			if(!visit[*it] && currentFlow[node][*it] < capacity[node][*it]) {
				visit[*it] = true;	// il marcam ca vizitat
				myQueue.push(*it);	// il introducem in coada
				father[*it] = node;	// ii retinem tatal (pentru reconstructia drumului)
			}
	}

	// returneaza daca exista drum de ameliorare
	return visit[destination];
}