#include <algorithm>
#include <fstream>
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

#define pb push_back
#define tr(C, i) for (typeof((C).begin()) i = (C).begin(); i != (C).end(); ++i)

const int oo = 1<<30;

int N;
vector< vector<int> > G;
vector< vector<int> > C, F;
vector<int> P;

bool bfs(int S, int D) {
	fill(P.begin(), P.end(), 0);

	queue<int> Q;
	Q.push(S);
	P[S] = S;

	while (!Q.empty()) {
		int u = Q.front();
		Q.pop();

		tr(G[u], vv) {
			int v = *vv;
			if (!P[v] && (C[u][v] - F[u][v] > 0)) {
				P[v] = u;
				Q.push(v);
				if (v == D)
					return true;
			}
		}
	}
	return false;
}

void printv(const vector<int> &v) {
	tr(v, ii)
		cout << *ii << " ";
	cout << endl;
}

void printm(const vector< vector<int> > &m) {
	tr(m, ii)
		printv(*ii);
}

int main(int argc, char *argv[]) {
	int M, u, v, w;
	ifstream fin("maxflow.in");
	fin >> N >> M;
	C.resize(N+1);
	fill(C.begin(), C.end(), vector<int>(N+1, 0));
	G.resize(N+1);
	while (M--) {
		fin >> u >> v >> w;
		C[u][v] = w;
		G[u].pb(v);
	}
	fin.close();

	P.resize(N+1);
	int ft = 0;
	F.resize(N+1);
	fill(F.begin(), F.end(), vector<int>(N+1, 0));
	while (bfs(1, N)) {
//		printv(P);

		int fmin = oo;
		for (int n = N; P[n] != n; n = P[n])
			fmin = min(fmin, C[P[n]][n] - F[P[n]][n]);
//		cout << fmin << endl;
		ft += fmin;

		for (int n = N; P[n] != n; n = P[n]) {
			F[P[n]][n] += fmin;
			F[n][P[n]] -= fmin;
		}

//		printm(F);
	}

	ofstream fout("maxflow.out");
	fout << ft << endl;
	fout.close();

	return 0;
}