#include<iostream>
#include<fstream>
#include<vector>
#include<queue>
#include<cstring>
#include<climits>
using namespace std;

int n,m;
int s,t;

struct muchie{
    int nodDest;
    int capacitate;
    int flux;
    int revers;
    
    muchie(int dest, int cap, int fl, int revers1)
    : nodDest(dest), capacitate(cap), flux(fl), revers(revers1){};
};

bool bfs(int nivele[], vector<muchie> muchii[]){
    for(int i=1;i<=n;i++)
        nivele[i]=-1;
            
    nivele[s]=0;
    queue<int> q;
    q.push(s);
    
    while(!q.empty()){
        int nod = q.front(); q.pop();
        for(muchie& m : muchii[nod]){
            if(nivele[m.nodDest] < 0 && m.flux < m.capacitate){
                nivele[m.nodDest] = nivele[nod] + 1;
                
                q.push(m.nodDest);
            }
        }
    }
    
    return nivele[t] > 0; //nu poate fi 0, s diferit de t
}

int trimite(int start, int flux, int indexRamas[], int nivele[], vector<muchie> muchii[]){
    if(start==t)
        return flux;
    
    for(; indexRamas[start] < muchii[start].size(); indexRamas[start]++){
        muchie& m = muchii[start][indexRamas[start]];
        if(nivele[m.nodDest] == nivele[start] + 1 && m.flux < m.capacitate){
            int fluxC;
            if(flux < m.capacitate - m.flux)
                fluxC = flux;
            else
                fluxC = m.capacitate - m.flux;
            
            int fluxT = trimite(m.nodDest, fluxC, indexRamas, nivele, muchii);
            if(fluxT > 0){
                m.flux += fluxT;
                muchii[m.nodDest][m.revers].flux -= fluxT;
                return fluxT;
            }
        }
    }
    
    return 0;
}


int main(){
    ifstream fin("maxflow.in");
    ofstream fout("maxflow.out");
    
    fin>>n>>m;
    s=1;
    t=n;
    vector<muchie> muchii[n+1];
    int nivele[n+1];
    int x,y,c;
    for(int i=0;i<m;i++){
        fin>>x>>y>>c;
        int lastPozX = muchii[x].size();
        int lastPozY = muchii[y].size();
        muchii[x].push_back(muchie(y, c, 0, lastPozY));
        muchii[y].push_back(muchie(x, 0, 0, lastPozX));
    }
    
    int maxFlux = 0;
    int indexiRamasi[n+1];
    while(bfs(nivele, muchii)){
        memset(indexiRamasi, 0, sizeof(int)*(n+1));
        int adaosFlux = trimite(s, INT_MAX, indexiRamasi, nivele, muchii);
        while(adaosFlux>0){
            maxFlux += adaosFlux;
            adaosFlux = trimite(s, INT_MAX, indexiRamasi, nivele, muchii);
        }
    }
    
    fout<<maxFlux;
    
    return 0;
}