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

#define INF 1000000000
#define NMAX 1005

bool reachedEnd;

int N, M;
int result;

int f[NMAX][NMAX];
int c[NMAX][NMAX];
int from[NMAX];

vector<int> edges[NMAX];

void updateFlux() {
    int minflux = INF;

    for(int i = N; from[i] != 0; i = from[i])
        minflux = min(minflux, c[from[i]][i] - f[from[i]][i]);

    if(!minflux)
        return;

    result += minflux;

    for(int i = N; from[i] != 0; i = from[i]) {
        f[from[i]][i] += minflux;
        f[i][from[i]] -= minflux;
    }

}

void bfs(int start) {
    queue<int> q;
    q.push(start);

    while( !q.empty() ) {
        int node = q.front();
        q.pop();
        if( node == N ) {
            reachedEnd = true;
            continue;
        }

        for( int x : edges[node] ) {
            if( from[x] || c[node][x] == f[node][x] || x == 1 )
                continue;

            from[x] = node;
            q.push(x);
        }
    }
}

void read(){
  ifstream fin("maxflow.in");
  int x, y, z;

  fin >> N >> M;

    for(int i = 1; i <= M; i++) {
        fin >> x >> y >> z;
        c[x][y] = z;
        edges[x].push_back(y);
        edges[y].push_back(x);
    }
}

int main() {
    read();

    reachedEnd = true;
    while(reachedEnd) {
        for( int i = 1; i <= N; i++ )
            from[i] = 0;

        reachedEnd = false;

        bfs(1);

        if( reachedEnd == false )
            break;

        for( int node : edges[N] ) {
            if( c[node][N] == f[node][N] || (from[node] == 0 && node != 1) )
                continue;

            from[N] = node;
            updateFlux();
        }
    }

    ofstream fout("maxflow.out");
    fout << result;

    return 0;
}