// Ilie Dumitru
#include<cstdio>
#include<vector>
#include<bitset>
#include<queue>
const int NMAX=1005, MAXPUSH=110000;

struct edge
{
	int node, left, idxOther;
};

struct state
{
	int node, flow;

	state(int node=0, int flow=MAXPUSH) : node(node), flow(flow) {}
};

int N, M;
std::vector<edge> G[NMAX];
int ans;
std::bitset<NMAX> vis;
int par[NMAX], idxPar[NMAX];

void addEdge(int u, int v, int w)
{
	G[u].push_back({v, w, (int)G[v].size()});
	G[v].push_back({u, 0, (int)G[u].size()-1});
}

void useEdge(edge& e, int flow)
{
	e.left-=flow;
	G[e.node][e.idxOther].left+=flow;
}

void goUp(int node, int flow)
{
	while(par[node]!=-1)
	{
		useEdge(G[par[node]][idxPar[node]], flow);
		node=par[node];
	}
}

int bfs(int source, int target)
{
	int i, nn, fl;
	std::queue<state> q;
	state s;

	q.push(source);
	par[source]=-1;
	vis.reset();
	vis[source]=1;

	do
	{
		s=q.front();
		q.pop();

		if(s.node==target)
		{
			goUp(target, s.flow);
			return s.flow;
		}

		for(i=0;i<(int)G[s.node].size();++i)
		{
			if(!vis[G[s.node][i].node] && G[s.node][i].left)
			{
				nn=G[s.node][i].node;
				fl=std::min(s.flow, G[s.node][i].left);
				par[nn]=s.node;
				idxPar[nn]=i;
				vis[nn]=1;

				q.push(state(nn, fl));
			}
		}
	}while(!q.empty());

	return 0;
}

bool edmondsKarp(int source, int target)
{
	int x=bfs(source, target);

	ans+=x;
	return x;
}

int main()
{
	FILE* f=fopen("maxflow.in", "r"), *g=fopen("maxflow.out", "w");
	int i, a, b, c;

	fscanf(f, "%d%d", &N, &M);
	for(i=0;i<M;++i)
	{
		fscanf(f, "%d%d%d", &a, &b, &c);
		addEdge(a-1, b-1, c);
	}

	while(edmondsKarp(0, N-1));

    fprintf(g, "%d\n", ans);

	fclose(f);
	fclose(g);
	return 0;
}