#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
ifstream f("maxflow.in");
ofstream g("maxflow.out");

int N, M, x, y, c, flux[1005][1005], cap[1005][1005], dad[1005];
vector < int > G[1005];
queue < int > Q;

inline bool bfs(int source, int sink)
{
    Q.push(source);
    for (int i=1; i<=N; ++i)
        dad[i]=0; dad[source]=source;

    while (Q.size())
    {
        int nod=Q.front(); Q.pop();
        if (nod==sink) continue;
        vector<int>::iterator it=G[nod].begin();

        for (; it!=G[nod].end(); ++it)
            if (!dad[*it] && cap[nod][*it]>flux[nod][*it])
                dad[*it]=nod, Q.push(*it);
    }
    return (dad[sink]>0);
}

int flow(int source, int sink)
{
    int maxflow=0;
    for (; bfs(source, sink); )
    {
        vector<int>::iterator it=G[sink].begin();
        for (; it!=G[sink].end(); ++it)
            if (dad[*it] && cap[*it][sink]>flux[*it][sink])
            {
                int minim=(1<<30); dad[sink]=*it;
                for (int x=sink; x!=source; x=dad[x])
                    minim=min(minim, cap[dad[x]][x]-flux[dad[x]][x]);

                if (minim!=(1<<30))
                {
                    maxflow+=minim;
                    for (int x=sink; x!=source; x=dad[x])
                        flux[dad[x]][x]+=minim, flux[x][dad[x]]-=minim;
                }
            }
    }
    return maxflow;
}

int main()
{
    f>>N>>M;
    for (int i=1; i<=M; ++i)
    {
        f>>x>>y>>c; cap[x][y]+=c;
        G[x].push_back(y); G[y].push_back(x);
    }

    g<<flow(1, N)<<'\n';
    return 0;
}