var f,c:array[1..1000,1..1000] of longint;
graf:array[1..1000] of array of integer;
nodi,mini,p,n,i,j,k,l,flux,m,x,y,cap,nod:longint;
fol:array[1..1000] of byte;
ant:array[1..1000] of integer;
//parcurgere pt flux

function bf:boolean;
var i,j:longint;
v:array[1..1000] of longint;
begin
fillchar(fol,sizeof(fol),0);
fillchar(v,sizeof(v),0);
fol[1]:=1;
v[1]:=1;
k:=1;
i:=0;bf:=false;
while i<k do
	begin
	inc(I);
        if v[i]<>n then
	for j:=1 to graf[v[i]][0] do
		begin
		nod:=graf[v[i]][j];
		if (fol[nod]=0)and (f[v[i]][nod]<c[v[i]][nod]) then
                begin
			fol[nod]:=1;
			inc(K);
			v[k]:=nod;
			ant[nod]:=v[i];
			end;
		end;
	end;
if fol[n]=1 then bf:=true;
end;

function min(x,y:longint):longint;
begin
if x<y then min:=x
else min:=y;
end;

begin
assign(input,'maxflow.in');
assign(output,'maxflow.out');
reset(input);
rewrite(output);
//citire

read(n,m);
for i:=1 to n do setlength(graf[i],1);
for i:=1 to m do
		begin
		read(x,y,cap);
                if x<>y then
                begin
			inc(c[x][y],cap);

		inc(graf[x][0]);
		inc(graf[y][0]);
		setlength(graf[x],graf[x][0]+1);
		setlength(graf[y],graf[y][0]+1);
		graf[x][graf[x][0]]:=y;
		graf[y][graf[y][0]]:=x;
                end
                else
                begin
                c[x][x]:=cap;
                inc(graf[x][0]);
                setlength(graf[x],graf[x][0]+1);
                graf[x][graf[x][0]]:=x;
		end;
                end;

// calculare flux
flux:=0;
while bf do
	for i:=1 to graf[n][0] do
		 begin
		 nod:=graf[n][i];
		 if (fol[nod]=1) and (c[nod][n]<>f[nod][n]) then
			begin
			ant[n]:=nod;
			nodi:=n;   mini:=maxlongint;
			while nodi <> 1 do
			begin
			mini:=min(mini,c[ant[nodi]][nodi]-f[ant[nodi]][nodi]);
			nodi:=ant[nodi];
			end;
			nodi:=n;  if mini<>0 then
			while nodi <> 1 do
			begin
			inc(f[ant[nodi]][nodi],mini);
			dec(f[nodi][ant[nodi]],mini);
                        nodi:=ant[nodi];
			end;
			inc(flux,mini);
			end;
		end;


write(flux);
close(input);
close(output);
end.