#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <stack>
#include <queue>

#include <iomanip>

#define int long long

using namespace std;

string filename = "maxflow";

#ifdef LOCAL
    ifstream fin("input.in");
    ofstream fout("output.out");
#else
    ifstream fin(filename + ".in");
    ofstream fout(filename + ".out");
#endif

const int NMAX = 1000;
const int INF = 1e9 + 1;

int n, m;
vector <int> adj[NMAX + 1];

int flow[NMAX + 1][NMAX + 1];

bool viz[NMAX + 1];
int parent[NMAX + 1];

bool BFS(int source){
    for(int i = 1; i <= n; i++){
        parent[i] = 0;
        viz[i] = 0;
    }

    queue <int> Q;
    Q.push(source);
    viz[source] = true;

    while(!Q.empty()){
        int node = Q.front();
        Q.pop();

        if(node == n){
            return true;
        }

        for(int vec : adj[node]){
            if(!viz[vec] && flow[node][vec] > 0){
                parent[vec] = node;
                viz[vec] = true;
                Q.push(vec);
            }
        }
    }

    return false;
}

signed main(){

    fin >> n >> m;

    for(int i = 1; i <= m; i++){
        int a, b, c;
        fin >> a >> b >> c;
        adj[a].push_back(b);
        adj[b].push_back(a);
        flow[a][b] = c;
    }

    int maxFlow = 0;

    while(BFS(1)){
        for(int vec : adj[n]){
            if(flow[vec][n] <= 0 || !viz[vec]){
                continue;
            }
            
            parent[n] = vec;

            int mini = INF, node = n;
            while(node != 1){
                mini = min(mini, flow[parent[node]][node]);
                node = parent[node];
            }

            if(mini == 0){
                continue;
            }

            node = n;
            while(node != 1){
                flow[parent[node]][node] -= mini;
                flow[node][parent[node]] += mini;
                node = parent[node];
            }

            maxFlow += mini;
        }
    }

    fout << maxFlow << '\n';

    return 0;
}