#include <fstream>
#include <vector>
#include <deque>
#include <unordered_map>
#include <climits>
using namespace std;

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

int n, m, x, y, c;
struct edge {
    int x;
    int y;
    int capacity;
    bool reverse = false;
    int flow = 0;
    int residual = capacity;
};

void dfs(deque<int>& path, int flow, vector<unordered_map<int, edge>>& list, vector<int>& visited, deque<int>& best_path, int& best_flow, int dest = n) {
    int current = path[path.size() - 1];
    if (current == dest) {
        best_flow = flow;
        best_path = path;
    }
    else if (current != dest) {
        for (auto& item : list[current]) {
            edge e = item.second;
            int possible_flow = min(flow, e.residual);
            if (possible_flow > visited[e.y] && best_flow == 0) { 
                visited[current] = possible_flow;
                path.push_back(e.y);
                dfs(path, possible_flow, list, visited, best_path, best_flow);
                path.pop_back();
            }
        }
    }
}


void update(edge& e, edge& r, int flow) {
    if (!e.reverse) {
        e.flow += flow;
        e.residual = e.capacity - e.flow;
        r.residual = e.flow;
    }
    else {
        edge& aux = e;
        e = r;
        r = aux;
        e.flow -= flow;
        e.residual = e.capacity - e.flow;
        r.residual = e.flow;
    }
}

int ford_fulkerson(vector<unordered_map<int, edge>>& list, int source = 1, int dest = n) {
    int max_flow = 0;
    while (true) {

        int flow = 0;
        deque<int> path;
        deque<int> current_path;
        vector<int> visited(n + 1, 0);
        current_path.push_back(source);
        visited[source] = INT_MAX;
        dfs(current_path, INT_MAX, list, visited, path, flow);

        if (path.size() == 0 || path[path.size() - 1] != dest) {
            break;
        }

        for (int i = 0; i < path.size() - 1; i++) {
            x = path[i];
            y = path[i + 1];
            update(list[x][y], list[y][x], flow);
        }

        max_flow += flow;
    }
    return max_flow;
}


int main()
{
    cin >> n >> m;
    unordered_map<int, edge > map;
    vector<unordered_map<int, edge>> list(n + 1, map);
    for (int i = 0; i < m; i++) {
        cin >> x >> y >> c;
        list[x][y] = { x,y,c,false };
        list[y][x] = { y,x,0,true };
    }

    int result = ford_fulkerson(list);

    cout << result << endl;
}