#include <bits/stdc++.h>
using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
bool apare[1005];
int pre[1005],C[1005][1005],flux[1005][1005],n;
vector <int> G[1005];
queue <int> Q;
void bfs();
int main()
{
    int i,m,fluxtotal=0,mini,x,y,c,nod,urm;
    fin>>n>>m;
    for(i=1;i<=m;i++)
    {
        fin>>x>>y>>c;
        C[x][y]=c;
        G[x].push_back(y);
        G[y].push_back(x);
    }


    while(1)
    {
       bfs();
       if(!apare[n]) break;
       for(i=0;i<G[n].size();i++)
            if (apare[G[n][i]] && C[G[n][i]][n]>flux[G[n][i]][n])
            {
                 nod=G[n][i];
                 urm=n;
                 mini=C[nod][urm]-flux[nod][urm];
                 while(nod)
                 {
                     mini=min(mini, C[nod][urm]-flux[nod][urm]);
                     urm=nod;
                     nod=pre[nod];
                 }
                 if(mini)
                 {
                     nod=G[n][i];
                     urm=n;
                     while(nod)
                     {
                         flux[nod][urm]+=mini;
                         flux[urm][nod]-=mini;
                         urm=nod;
                         nod=pre[nod];
                     }
                 }
                 fluxtotal+=mini;
            }
    }
    fout<<fluxtotal;
    return 0;
}

void bfs()
{
    int nod,vecin,i;
    for(i=1;i<=n;i++) {apare[i]=0; pre[i]=0;}
    apare[1]=1;
    pre[1]=0;
    Q.push(1);
    while(!Q.empty())
    {
        nod=Q.front();
        Q.pop();
        for(i=0;i<G[nod].size();i++)
        {
           vecin=G[nod][i];
           if (!apare[vecin] && C[nod][vecin]> flux[nod][vecin])
           {
               apare[vecin]=1;
               pre[vecin]=nod;
               Q.push(vecin);
           }
        }
    }
}