#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>

#define MAX 1005

using namespace std;

typedef struct {
	int d, f;
} Edge;

typedef struct {
	vector < vector <Edge> > E;
} Graph; 

int N, M, maxf;
Graph G, P;
bool visited[MAX];

void read () {
	scanf("%d %d", &N, &M);
	
	G.E.resize(N+1);
	
	for (int i = 0; i < M; ++i) {
		int x;
		Edge e;
		
		scanf("%d %d %d", &x, &e.d, &e.f);
		
		G.E[x].push_back(e);
	}
}

int bfs () {
	memset(visited, false, (N+1) * sizeof(bool));
	P.E.clear();
	P.E.resize(N+1);
	
	queue <int> Q;
	Q.push(1);
	visited[1] = true;
	
	int n = 0;
	
	while (!Q.empty()) {
		int x = Q.front();
		vector <Edge>::iterator it;
		for (it = G.E[x].begin(); it != G.E[x].end(); ++it) {
			if (!visited[it->d]) {
				Edge aux = {x, it->f};
				P.E[it->d].push_back(aux);
				if (it->d == N) {
					++n;
				} else {
					visited[it->d] = true;
					Q.push(it->d);
				}
			}
		}
		Q.pop();
	}
	
	return n;			 
}			

void maxflow() {
	int n = bfs();
	while (n) {
		vector <Edge>::iterator it;
		for (it = P.E[N].begin(); it != P.E[N].end(); ++it) {
			int min = it->f, x = it->d;
			while (x != 1) {
				if (P.E[x][0].f < min) min = P.E[x][0].f;
				x = P.E[x][0].d;
			}
			
			int prev = it->d;
			x = N;
			while (x != 1) {
				vector <Edge>::iterator jt;
				for (jt = G.E[x].begin(); jt != G.E[x].end(); ++jt) {
					if (jt->d == prev) break;
				}
				
				if (jt != G.E[x].end() && jt->d == prev) {
					jt->f += min;
				} else {
					Edge aux = {prev, min};
					G.E[x].push_back(aux);
				}
				
				for (jt = G.E[prev].begin(); jt != G.E[prev].end(); ++jt) {
					if (jt->d == x) break;
				}
				
				if (jt != G.E[prev].end() && jt->d == x) {
					jt->f -= min;				
					if (jt->f == 0) G.E[prev].erase(jt);
				}
				
				x = prev;
				if (prev != 1) prev = P.E[prev][0].d;
			}
			
			maxf += min;
		}
		n = bfs();
	}	
}	

int main (void) {
	freopen("maxflow.in", "r", stdin);
	freopen("maxflow.out", "w", stdout);
	
	read();
	maxflow();
	
	printf("%d", maxf);
	return 0;
}