#include <cstdio>
#include <vector>
#include <queue>
#define NMAX 1000
#define inf 10000000

using namespace std;

int n,m,i,sol;
int T[NMAX+5],C[NMAX+5][NMAX+5],F[NMAX+5][NMAX+5];
queue <int> q;
vector <int> G[NMAX+5];

bool bfs()
{
    int node,i,s,son;
    bool ok=false;

    for(i=1; i<=n; ++i)
        T[i]=0;

    q.push(1);
    T[1]=-1;

    while(!q.empty())
    {
        node=q.front();
        q.pop();
        s=G[node].size();

        for(i=0; i<s; ++i)
        {
            son=G[node][i];

            if(!T[son] && C[node][son]>F[node][son])
            {
                if(son==n)
                    ok=true;
                else
                {
                    T[son]=node;
                    q.push(son);
                }
            }
        }
    }
    return ok;
}

int main()
{
    freopen("maxflow.in","r",stdin);
    freopen("maxflow.out","w",stdout);

    scanf("%d%d",&n,&m);

    for(i=1; i<=m; ++i)
    {
        int x,y,c;

        scanf("%d%d%d",&x,&y,&c);

        G[x].push_back(y);
        G[y].push_back(x);
        C[x][y]=c;

    }

    while(bfs())
    {
        int node,s=G[n].size();

        for(i=0; i<s; ++i)
        {
            int flux=inf;
            node=n;
            T[node]=G[n][i];

            while(T[node]!=-1 && flux)
            {
                flux=min(flux,C[T[node]][node]-F[T[node]][node]);
                node=T[node];
            }

            if(!flux)
                continue;

            sol+=flux;
            node=n;

            while(T[node]!=0)
            {
                F[T[node]][node]+=flux;
                F[node][T[node]]-=flux;
                node=T[node];
            }
        }
    }

    printf("%d\n",sol);

    return 0;
}