#include <fstream>
#include <vector>
#include <queue>
#define NMAX 1003
using namespace std;

vector<int> G[NMAX];
queue<int> Q;
int C[NMAX][NMAX], F[NMAX][NMAX], T[NMAX], n, m;
bool U[NMAX];

ifstream f("maxflow.in");
ofstream g("maxflow.out");

int BFS()
{   int i, nod, k;
    for (i=1; i<=n; ++i)
        U[i]=0;
    Q.push(1);
    U[1]=1;
    while (!Q.empty())
    {   nod=Q.front();
        Q.pop();
        for (i=0; i<G[nod].size(); ++i)
        {   k=G[nod][i];
            if (!U[k] && C[nod][k]!=F[nod][k])
            {   U[k]=1;
                if (k!=n)
                {   Q.push(k);
                    T[k]=nod;
                }
            }
        }
    }
    return U[n];
}

int main()
{   int i, j, x, y, z;
    f>>n>>m;
    for (i=1; i<=m; ++i)
    {   f>>x>>y>>z;
        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y]=z;
    }
    int flux, fmin;
    for (flux=0; BFS(); )
    {   for (i=0; i<G[n].size(); ++i)
            if (U[G[n][i]])
            {   j=G[n][i];
                T[n]=j;
                fmin=C[j][n]-F[j][n];
                while (T[j])
                {   fmin=min(fmin, C[T[j]][j]-F[T[j]][j]);
                    j=T[j];
                }
                if (fmin)
                {   flux+=fmin;
                    j=n;
                    while (T[j])
                    {   F[T[j]][j]+=fmin;
                        F[j][T[j]]-=fmin;
                        j=T[j];
                    }
                }
            }
    }
    g<<flux;
    return 0;
}