///MAXFLOW
#include <iostream>
#include <fstream>
#include <vector>
#include <list>
#include <queue>
#include <limits>

using namespace std;

unsigned getCurrentCapacity(vector<vector<unsigned> >& capacities,
		vector<short>& previous, short sink) {
	unsigned currentCapacity = numeric_limits<unsigned>::max();

	short prev;
	while(previous[sink] > -1) {
		prev = previous[sink];
		if(capacities[prev][sink] < currentCapacity)
			currentCapacity = capacities[prev][sink];
		sink = prev;
	}

	return currentCapacity;
}

void updateNetwork(vector<vector<unsigned> >& capacities,
		vector<short>& previous, short sink, unsigned flow) {
	short prev;
	while(previous[sink] > -1) {
		prev = previous[sink];
		capacities[prev][sink] -= flow;
		capacities[sink][prev] += flow;
		sink = prev;
	}
}

unsigned getMaxFlow(vector<list<short> >& adjList,
		vector<vector<unsigned> >& capacities, short sink) {
	unsigned maxFlow = 0, currentCapacity;
	bool isAugmentedPath = true;

	while(isAugmentedPath) {
		isAugmentedPath = false;
		///BFS
		queue<short> q;
		vector<short> previous(adjList.size(), -1);

		q.push(0);

		short current;
		list<short>::iterator it;
		while(!q.empty()) {
			current = q.front();
			q.pop();

			for(it = adjList[current].begin(); it != adjList[current].end(); it++)
				if((*it == sink || previous[*it] == -1) && capacities[current][*it] > 0 && *it != 0) {
					previous[*it] = current;
					if(*it == sink) {
						currentCapacity = getCurrentCapacity(capacities, previous, sink);
						maxFlow += currentCapacity;
						updateNetwork(capacities, previous, sink, currentCapacity);
						isAugmentedPath  = true;
					}
					else
						q.push(*it);
				}
		}
	}

	return maxFlow;
}

int main() {
	ifstream inStr("maxflow.in");
	ofstream outStr("maxflow.out");

	short numNodes, numEdges;
	inStr >> numNodes >> numEdges;

	vector<list<short> > adjList(numNodes);
	vector<vector<unsigned> > capacities(numNodes, vector<unsigned>(numNodes, 0));

	short from, to;
	unsigned capacity;
	for(short i=0; i < numEdges; i++) {
		inStr >> from >> to >> capacity;
		adjList[--from].push_back(--to);
		adjList[to].push_back(from);
		capacities[from][to] = capacity;
	}

	outStr <<getMaxFlow(adjList, capacities, numNodes - 1) << '\n';

	return 0;
}