#include <bits/stdc++.h>

using namespace std;
typedef int ll;
const ll NMAX=5e3+5;
struct Edge{
    ll u,v,flow=0,cap;
}edg_list[NMAX*2];
vector<ll> edg[NMAX];
ll layer[NMAX],ptr[NMAX];
ll s,t,n,m;
ll dfs(ll u, ll flow){
    if(!flow || u==t) return flow;
    for(ll& i=ptr[u];i<edg[u].size();i++){
        ll id=edg[u][i],v=edg_list[id].v;
        if(layer[v]==layer[u]+1 && edg_list[id].cap-edg_list[id].flow > 0){
            ll new_flow=dfs(v,min(flow,edg_list[id].cap-edg_list[id].flow));

            edg_list[id].flow+=new_flow;
            edg_list[id^1].flow-=new_flow;

            return new_flow;
        }
    }
    return 0;
}
int main()
{
    ifstream fin("maxflow.in");
    ofstream fout("maxflow.out");
    fin>>n>>m;
    for(ll i=0;i<m;i++){
        fin>>edg_list[i*2].u>>edg_list[i*2].v>>edg_list[i*2].cap;
        edg_list[i*2+1].u=edg_list[i*2].v,
        edg_list[i*2+1].v=edg_list[i*2].u;

        edg[edg_list[i*2].u].push_back(i*2);
        edg[edg_list[i*2+1].u].push_back(i*2+1);
    }
    s=1,t=n;
    ll ans=0;
    for(;;){
        for(ll i=1;i<=n;i++)
            layer[i]=-1,ptr[i]=0;
        layer[s]=0;
        queue<ll> q;
        q.push(s);
        while(!q.empty()){
            for(auto it : edg[q.front()]){
                if(layer[edg_list[it].v]==-1 && edg_list[it].cap-edg_list[it].flow>0)
                    layer[edg_list[it].v]=layer[q.front()]+1,q.push(edg_list[it].v);
            }
            q.pop();
        }
        if(layer[t]==-1)
            break;
        int iter=0;
        for(;;){
            ll new_flow=dfs(s,INT_MAX);
            if(new_flow==0) break;
            iter++;
            ans+=new_flow;
        }
        if(iter==0) break;
    }
    fout<<ans<<'\n';
    return 0;
}