// Include
#include <fstream>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

// Definitii
#define pb push_back

// Constante
const int sz = (int)1e3+1;
const int oo = (1<<30)-1;
const int source = 1;

// Functii
bool bfs();

// Variabile
ifstream in("maxflow.in");
ofstream out("maxflow.out");

int destination, edges; // Numarul de noduri (ultimul nod fiind destinatia) si numarul de muchii
int maxFlow; // Raspunsul

int father[sz]; // Vectorul de tati pentru a retine drumurile

int emptySpace[sz][sz]; // Matricea de costuri a grafului. emptySpace[x][y] va contine numarul de unitati de flux ce mai pot fi trimise pe muchia x->y
vector<int> graph[sz]; // Graful neorientat reprezentat prin liste de vecini

// Main
int main()
{
	in >> destination >> edges;
	
	int rFrom, rTo, rCapacity;
	while(edges--)
	{
		in >> rFrom >> rTo >> rCapacity;
		graph[rFrom].pb(rTo);
		graph[rTo].pb(rFrom);
		
		emptySpace[rFrom][rTo] = rCapacity;
	}
	
	// Cat timp mai gasesc un drum prin care se poate trimite cel putin o unitate de flux de la sursa la destinatie
	while(bfs())
	{
		// Iau toti vecinii destinatiei
		vector<int>::iterator it, end=graph[destination].end();
		
		for(it=graph[destination].begin() ; it!=end ; ++it)
		{
			// Daca am avut un drum pana la acel vecin si pot trimite flux de la el la destinatie
			// Il consider tata, pentru a putea merge de la destinatie la sursa pe drumul invers
			if(!emptySpace[*it][destination] || !father[*it])
				continue;
			
			int minFlow = oo; // Minimul dintre spatiul ramas al muchiilor ce formeaza drumul | Fluxul maxim ce-l pot trimite pe acel drum
			
			// De la destinatie la sursa, din tata in tata
			for(int node=destination ; node!=source ; node=father[node])
				minFlow = min(minFlow, emptySpace[father[node]][node]);
			
			// Pe acelasi drum, scad minFlow din spatiul ramas (cel putin una dintre muchii va ajunge la 0), adaugandu-l pe muchia inversa
			for(int node=destination ; node!=source ; node=father[node])
			{
				emptySpace[father[node]][node] -= minFlow;
				emptySpace[node][father[node]] += minFlow;
			}
			
			// Cresc fluxul maxim cu numarul de unitati trimise
			maxFlow += minFlow;
		}
	}
	
	out << maxFlow << '\n';
	
	in.close();
	out.close();
	return 0;
}

bool bfs()
{
	// Consider ca un nod este vizitat doar atunci cand are tata
	memset(father, 0, sizeof(father));
	
	queue<int> bfq;
	
	// Introduc primul nod in coada. Presupun ca are tatal -1 pentru a-l vedea vizitat.
	bfq.push(source);
	father[source] = -1;
	
	// Parcurgere in latime
	// Cat timp coada nu este goala
	while(!bfq.empty())
	{
		// Iau nodul din fata si il sterg din coada
		int node = bfq.front();
		bfq.pop();
		
		// Daca am ajuns la destinatie, ma opresc
		if(node == destination)
			break;
		
		// Iau toti vecinii nodului curent
		vector<int>::iterator it, end=graph[node].end();
		for(it=graph[node].begin() ; it!=end ; ++it)
		{
			// Daca vecinul nu este vizitat si daca mai pot trimite cel putin o unitate de flux pe muchia de la nod la el
			if(!father[*it] && emptySpace[node][*it])
			{
				// Introduc vecinul in coada
				bfq.push(*it);
				
				// Il setez pe nodul curent ca tata al vecinului, pentru a putea forma drumul invers
				father[*it] = node;
			}
		}
	}
	
	// Daca am terminat toate nodurile si nu am ajuns la destinatie, inseamna ca nu mai exista drumuri libere
	return father[destination]? true : false;
}