#include <bits/stdc++.h>
 
using namespace std;
 
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
 
const int N = 1005;
 
int n,m,x,y,c,Flow[N][N],Cap[N][N],sink,source=1,t[N],seen[N],Min,MaxFlow;
 
vector <int> G[N];
 
void Read()
{
    fin>>n>>m;
    while(m--)
        {
            fin>>x>>y>>c;
            Cap[x][y]=c;
            G[x].push_back(y);
            G[y].push_back(x);
        }
    sink=n;
}
 
queue <int> Q;
 
int BFS(int source, int sink)
{
    memset(seen,0,sizeof(seen));
    memset(t,0,sizeof(t));
    Q.push(source);
    seen[source]=1;
    while(!Q.empty())
        {
            int nod=Q.front();
            vector <int> ::iterator it;
            Q.pop();
            for(it=G[nod].begin();it!=G[nod].end();it++)
                {
                    int next=(*it);
                    if(!seen[next] && Cap[nod][next]-Flow[nod][next]>0)
                        {
                            t[next]=nod;
                            seen[next]=1;
                            Q.push(next);
                        }
                }
        }
    if(!t[sink])
        return false;
    return true;
}
 
void FindFlow()
{
    while(BFS(source,sink))
        {
            vector <int> ::iterator it;
            for(it=G[sink].begin();it!=G[sink].end();it++)
                {
                    int next=(*it);
                    if(seen[next] && Cap[next][sink]-Flow[next][sink]>0)
                        {
                            Min=Cap[next][sink]-Flow[next][sink];
                            int p=next;
                            while(t[p]!=0)
                                {
                                    Min=min(Min,Cap[t[p]][p]-Flow[t[p]][p]);
                                    p=t[p];
                                }
                            if(Min>0)
                                {
                                    MaxFlow+=Min;
                                    p=next;
                                    Flow[next][sink]+=Min;
                                    Flow[sink][next]-=Min;
                                    while(t[p]!=0)
                                        {
                                            Flow[t[p]][p]+=Min;
                                            Flow[p][t[p]]-=Min;
                                            p=t[p];
                                        }
                                }
                        }
                }
        }
    fout<<MaxFlow<<'\n';
}
 
int main()
{
    Read();
    FindFlow();
}