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

using namespace std;

const int INF = numeric_limits<int>::max();

int getCap(vector<int>& prev, vector<vector<int> >& cap, int sink) {
	int currCap = INF;
	int curr = sink;
	while(prev[curr] != -1) {
		currCap = min(currCap, cap[prev[curr]][curr]);
		curr = prev[curr];
	}
	return currCap;
}

void updateFlow(vector<int>& prev, vector<vector<int> >& cap, int sink, int currCap) {
	int curr = sink;
	while(prev[curr] != -1) {
		cap[prev[curr]][curr] -= currCap;
		cap[curr][prev[curr]] += currCap;
		curr = prev[curr];
	}
}

int getMaxFlow(vector<vector<int> >& adjList,
		vector<vector<int> >& cap, int source, int sink) {
	int flow = 0;
	bool isAugPath = true;
	vector<int> prev;	

	while(isAugPath) {
		isAugPath = false;
	
		prev.assign(adjList.size(), -1);

		queue<int> q;
		q.push(source);
		
		int curr;
		while(!q.empty()) {
			curr = q.front();
			q.pop();			

			for(auto i=adjList[curr].begin(); i!=adjList[curr].end(); ++i) {
				if((prev[*i] == -1 || *i == sink) && *i != source && cap[curr][*i] != 0) {
					prev[*i] = curr;
					if(*i == sink) {
						int currCap = getCap(prev, cap, sink);
						if(currCap != 0) {
							flow += currCap;
							updateFlow(prev, cap, sink, currCap);
							isAugPath = true;
						} else 
							isAugPath = false;
					} else q.push(*i);
				}
			}
		}
	}

	return flow;
}

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

	int N, M;
	inStr >> N >> M;

	vector<vector<int> > adjList(N);
	vector<vector<int> > cap(N, vector<int>(N, 0));

	int from, to, c;
	for(int i=0; i<M; ++i) {
		inStr >> from >> to >> c;
		adjList[--from].push_back(--to);
		adjList[to].push_back(from);
		cap[from][to] = c;
	}

	outStr << getMaxFlow(adjList, cap, 0, N-1) << '\n';

	return 0;
}