#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
#define nmax 1000
using namespace std;
ifstream f ("maxflow.in");
ofstream g ("maxflow.out");
int n, m, start, finish, max_flow;

vector< vector < pair<int, int> > > v(nmax+5);
vector<int> parinte(nmax+5);
vector<int> viz(nmax+5);
int gr[nmax+5][nmax+5];
queue <int> que;

bool bfs()
{
    int ok=0;
    while(!que.empty())
    {
        int nod=que.front();
        que.pop();
        if(nod!=n)
        {
            for(int i=0; i<v[nod].size(); i++)
            {
                int dest=v[nod][i].first;
                if(gr[nod][dest] && viz[dest]==0)
                {
                    que.push(dest);

                    if(dest==n)
                        ok=1;
                    viz[dest]=1;
                    parinte[dest]=nod;
                }
            }
        }
    }
    return ok;
}


int ford_fulkerson(int start, int finish)
{
    int u,q;
    que.push(1);
    while(bfs())
    {
        for(int i=0; i<v[n].size(); i++)
        {
            int sursa, capacitate;
            sursa=v[n][i].first;
            capacitate=v[n][i].second;

            if(gr[sursa][n] && viz[sursa]==1 && gr[n][sursa]!=capacitate)
            {
                int nod=sursa;
                int cap=gr[sursa][n];
                while(nod!=1)
                {
                    cap=min(cap, gr[parinte[nod]][nod]);
                    nod=parinte[nod];
                }

                nod=sursa;
                gr[nod][n]-=cap;
                gr[n][nod]+=cap;
                while(nod!=1)
                {
                    gr[parinte[nod]][nod]-=capacitate;
                    gr[parinte[nod]][nod]-=capacitate;
                    nod=parinte[nod];
                }
                max_flow+=cap;
            }
        }
        que.push(1);
        fill(parinte.begin(), parinte.end(), 0);
        fill(viz.begin(), viz.end(), 0);
    }
    return max_flow;

}

vector<pair<int, int>> muchii;

int main()
{
    int ok=1;
    f>>n>>m;
    for(int i=0; i<m; i++)
    {
        int x, y, z, t;
        f>>x>>y>>z;
        v[x].push_back(make_pair(y,z));
        v[y].push_back(make_pair(x,z));
        gr[x][y]=z;
    }
    g<<ford_fulkerson(1, n)<<"\n";

    return 0;
}