#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;
				if (v == D)
					continue;
				Q.push(v);
			}
		}
	}
	return (P[D] != 0);
}

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);
		G[v].pb(u);
	}
	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)) {
		tr(G[N], vv) {
			if (C[*vv][N] - F[*vv][N] == 0)
				continue;
			int fmin = oo;
			P[N] = *vv;
			for (int n = N; P[n] != n; n = P[n])
				fmin = min(fmin, C[P[n]][n] - F[P[n]][n]);
			ft += fmin;

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

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

	return 0;
}