#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
using namespace std;
  
const string file = "maxflow";
  
const string infile = file + ".in";
const string outfile = file + ".out";


struct Arc
{
	int dst;
	int cap;
	int flux;
	int p;
	Arc(int dst, int cap, int p)
	{
		this->flux = 0;
		this->dst = dst;
		this->cap = cap;
		this->p = p;
	}
};


int N, M;
vector<vector<int> > G;
vector<Arc> arcs;
vector<int> bfsParent;
vector<int> bfsArc;

int MaxFlow;

bool BFS()
{
	bfsParent.clear();
	bfsParent.resize(N + 1);
	bfsArc.clear();
	bfsArc.resize(N + 1);

	queue<int> q;
	q.push(1);


	while(q.empty() == false)
	{
		int current = q.front();
		q.pop();

		if(current == N) return true;

		for(vector<int>::iterator itr = G[current].begin();
			itr != G[current].end();
			itr++)
		{
			if(bfsParent[arcs[*itr].dst] == 0 && arcs[*itr].cap - arcs[*itr].flux > 0)
			{
				bfsArc[arcs[*itr].dst] = *itr;
				bfsParent[arcs[*itr].dst] = current;
				q.push(arcs[*itr].dst);
			}
		}
	}
	return false;
}



int main()
{
	fstream fin(infile.c_str(), ios::in);
	fin >> N >> M;
	G.resize(N + 1);
	for(int i = 0; i < M; i++)
	{
		int x, y, c;
		fin >> x >> y >> c;
		
		G[x].push_back(arcs.size());
		G[y].push_back(arcs.size() + 1);

		Arc arc(y, c, arcs.size() + 1);
		Arc rev(x, 0, arcs.size());

		arcs.push_back(arc);
		arcs.push_back(rev);
		
	}

	fin.close();


	while(BFS())
	{
		for(vector<int>::iterator itr = G[N].begin();
			itr != G[N].end();
			itr++)
		{
			if(bfsParent[arcs[*itr].dst] != 0)
			{
				bfsParent[N] = arcs[*itr].dst;
				bfsArc[N] = arcs[*itr].p;

				int maxFlow = arcs[arcs[*itr].p].cap - arcs[arcs[*itr].p].flux; 
				
				if(maxFlow <= 0) continue;

				for(int current = N; current != 1; current = bfsParent[current])
				{
					maxFlow = min(maxFlow, arcs[bfsArc[current]].cap - arcs[bfsArc[current]].flux); 
				}

				for(int current = N; current != 1; current = bfsParent[current])
				{
					arcs[bfsArc[current]].flux += maxFlow;
					arcs[arcs[bfsArc[current]].p].flux -= maxFlow; 
				}

				MaxFlow += maxFlow;
			}
		}
	}


	fstream fout(outfile.c_str(), ios::out);
	fout << MaxFlow << "\n";
	fout.close();
}