#include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
const int NMAX = 1055;
const int INF = 0x3f3f3f3f;

int N, M;
int cap[NMAX][NMAX];
int parent[NMAX];
vector<int> G[NMAX];

void read() {
	scanf("%d%d", &N, &M);
	int x, y, c;
	for (int edgeIdx = 0; edgeIdx < M; edgeIdx++) {
		scanf("%d%d%d", &x, &y, &c);
		cap[x][y] += c;
		G[x].push_back(y);
		G[y].push_back(x);
	}
}

bool bfs(int source, int dest) {
	queue<int> Q;
	fill(parent + 1, parent + N + 1, -1);
	Q.push(source);

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

		for (int neighbour : G[node]) {
			if (parent[neighbour] == -1 && cap[node][neighbour]) {
				parent[neighbour] = node;
				Q.push(neighbour);
				if (neighbour == dest) {
					return true;
				}
			}
		}
	}

	return false;
}

void addFlow(int& existingFlow, int source, int dest) {
	int currentFlow = INF, currNode = dest;
	while (currNode != source) {
		currentFlow = min(currentFlow, cap[parent[currNode]][currNode]);
		currNode = parent[currNode];
	}

	currNode = dest;
	while (currNode != source) {
		cap[parent[currNode]][currNode] -= currentFlow;
		cap[currNode][parent[currNode]] += currentFlow;
		currNode = parent[currNode];
	}

	existingFlow += currentFlow;
}

void solve(int source, int dest) {
	int flow = 0;
	while (bfs(source, dest)) {
		for (auto& candidatePrev : G[dest]) {
			if (cap[candidatePrev][dest]) {
				addFlow(flow, source, dest);
			}
		}
	}
	printf("%d\n", flow);
}

int main() {
	freopen("maxflow.in", "r", stdin);
	freopen("maxflow.out", "w", stdout);

	read();
	solve(1, N);
	return 0;
}