#include <bits/stdc++.h>
using namespace std;

struct Edge {
    int from, to;
    int capacity;
    int flow;
};

int N, M;
vector<Edge> edges;
vector<vector<int>> g; 
vector<int> parent;

bool bfs() {
    queue<int> que;
    que.push(1);
    parent.assign(N + 1, -1);
    parent[1] = M;
    
    while (!que.empty()) {
        int node = que.front();
        que.pop();
        if (node == N)
            continue;
        for (int edge_index : g[node]) {
            auto edge = edges[edge_index];
            if (parent[edge.to] != -1 || edge.capacity == edge.flow)
                continue;
            parent[edge.to] = edge_index;
            que.push(edge.to);
        }
    }
    
    return parent[N] != -1;
}

int main() {
    iftsream cin("maxflow.in");
    oftsream cout("maxflow.out");
    
    cin >> N >> M;
    edges.resize(2 * M);
    g.resize(N + 1, vector<int>());
    for (int i = 0; i < 2 * M; i += 2) {
        cin >> edges[i].from >> edges[i].to >> edges[i].capacity;
        edges[i + 1].from = edges[i].to;
        edges[i + 1].to = edges[i].from;
        g[edges[i].from].push_back(i);
        g[edges[i + 1].from].push_back(i + 1);
    }
    
    int max_flow = 0;
    while (bfs()) {
        for (int edge_from_dest_index : g[N]) {
            int edge_to_dest_index = edge_from_dest_index ^ 1;
            Edge edge_to_dest = edges[edge_to_dest_index];
            if (edge_to_dest.flow == edge_to_dest.capacity || parent[edge_to_dest.from] == -1)
                continue;
            parent[N] = edge_to_dest_index;
            
            int minim = 0x3f3f3f3f;
            for (int curr = N; curr != 1; curr = edges[parent[curr]].from)
                minim = min(minim, edges[parent[curr]].capacity - edges[parent[curr]].flow);
            for (int curr = N; curr != 1; curr = edges[parent[curr]].from) {
                edges[parent[curr]].flow += minim;
                edges[parent[curr] ^ 1].flow -= minim;
            }
            max_flow += minim;
        }
    }
    
    cout << max_flow << endl;
    
    return 0;
}

// Trust me, I'm the Doctor!