#include <bits/stdc++.h>

#define MAX_N 1000
#define MULT (1 << 30)

using namespace std;

struct FLOW {
    int s, t;
    int flux[MAX_N][MAX_N], parent[MAX_N], viz[MAX_N], cap[MAX_N][MAX_N];;
    vector <int> edges[MAX_N];

    void add_edge( int u, int v, int c ) {
        edges[u].push_back( v );
        edges[v].push_back( u );
        cap[u][v] = c;
    }

    bool bfs() {
        int u;
        queue <int> q;

        for ( u = 0; u < MAX_N; u++ )
            parent[u] = -1;
        for ( u = 0; u < MAX_N; u++ )
            viz[u] = 0;

        viz[s] = 1;
        q.push( s );
        while ( !q.empty() ) {
            u = q.front();
            q.pop();

            for ( int v: edges[u] ) {
                if ( !viz[v] && parent[v] == -1 && flux[u][v] < cap[u][v] ) {
                    parent[v] = u;
                    if ( v == t )
                        return 1;
                    q.push( v );
                    viz[v] = 1;
                }
            }
        }

        return 0;
    }

    int maxFlow() {
        int maxFlow, newFlow, v;

        maxFlow = 0;
        while ( bfs() ) {
            for ( int u: edges[t] ) {
                if ( viz[u] && flux[u][t] < cap[u][t] ) {
                    parent[t] = u;
                    newFlow = MULT;
                    v = t;
                    while ( v != s ) {
                        newFlow = min( newFlow, cap[parent[v]][v] - flux[parent[v]][v] );
                        v = parent[v];
                    }

                    maxFlow += newFlow;
                    v = t;
                    while ( v != s ) {
                        flux[parent[v]][v] += newFlow;
                        flux[v][parent[v]] -= newFlow;
                        v = parent[v];
                    }
                }
            }
        }

        return maxFlow;
    }
};

FLOW flow;

int main() {
    ifstream cin( "maxflow.in" );
    ofstream cout( "maxflow.out" );

    int n, m, u, v, c, i;

    cin >> n >> m;
    for ( i = 0; i < m; i++ ) {
        cin >> u >> v >> c;
        u--;
        v--;
        flow.add_edge( u, v, c );
    }

    flow.s = 0;
    flow.t = n - 1;

    cout << flow.maxFlow();

    return 0;
}