#include <fstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <iomanip>

#define NMax 1001
#define INF 0x3f3f3f3f
using namespace std;
ifstream w("maxflow.in");
ofstream g("maxflow.out");

int viz[NMax],tata[NMax];
int c[NMax][NMax],f[NMax][NMax];
queue<int> q;
vector<int> G[NMax];
int x,y,r,n,m,F,fm,nod,start;

bool bfs(){
    memset(viz,0,sizeof(viz));

    q.push(1);
    viz[1] = 1;
    tata[1] = 0;

    while(!q.empty()){
        int nod = q.front();
        q.pop();
        for(int i = 0; i < G[nod].size() && nod != n; ++i){

            if(f[nod][G[nod][i]] != c[nod][G[nod][i]] && !viz[G[nod][i]]){
                viz[G[nod][i]] = 1;

                q.push(G[nod][i]);

                tata[G[nod][i]] = nod;
            }
        }
    }
    if(viz[n] == 0)
        return 0;
    return 1;
}
int main()
{
  //  g << 1.0*(sizeof(c) + sizeof(f))/1024/1024 << '\n';
    w >> n >> m;
    for(int i = 1; i <= m; ++i){
        w >> x >> y >> r;
        c[x][y] += r;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    F = 0;

    while(bfs()){
        for(int i = 0; i < G[n].size(); ++i){

            nod = G[n][i];
            if(c[G[n][i]][n] == f[G[n][i]][n] || !viz[G[n][i]])
                continue;
            tata[n] = nod;

            fm = INF;
            start = n;
            while(start != 1){
                fm = min(fm,c[tata[start]][start] - f[tata[start]][start]);
                start = tata[start];
            }
            if(fm == 0)
                continue;

            start = n;
            while(start != 1){
                f[start][tata[start]] -= fm;
                f[tata[start]][start] += fm;
                start = tata[start];
            }

            F += fm;
        }
    }
    g << F;
    return 0;
}