#include<bits/stdc++.h>

using namespace std;

struct Edge {
    int v;
    int flow;
    int C;
    int rev;
};

class Graph {
    int V;
    int *level;
    vector<Edge> *adj;
public :
    explicit Graph(int V) {
        adj = new vector<Edge>[V];
        this->V = V;
        level = new int[V];
    }

    void addEdge(int u, int v, int C) {
        Edge a{v, 0, C, static_cast<int>(adj[v].size())};
        Edge b{u, 0, 0, static_cast<int>(adj[u].size())};
        adj[u].push_back(a);
        adj[v].push_back(b);
    }

    void delEdge(int u, int v) {
        adj[u].pop_back();
        adj[v].pop_back();
    }

    bool BFS(int s, int t) {
        for (int i = 0; i < V; i++)
            level[i] = -1;
        level[s] = 0;
        list<int> q;
        q.push_back(s);
        vector<Edge>::iterator i;
        while (!q.empty()) {
            int u = q.front();
            q.pop_front();
            for (i = adj[u].begin(); i != adj[u].end(); i++) {
                Edge &e = *i;
                if (level[e.v] < 0 && e.flow < e.C) {
                    level[e.v] = level[u] + 1;
                    q.push_back(e.v);
                }
            }
        }
        return level[t] >= 0;
    }

    int sendFlow(int u, int flow, int t, int start[]) {
        if (u == t)
            return flow;
        for (; start[u] < adj[u].size(); start[u]++) {
            Edge &e = adj[u][start[u]];
            if (level[e.v] == level[u] + 1 && e.flow < e.C) {
                int curr_flow = min(flow, e.C - e.flow);
                int temp_flow = sendFlow(e.v, curr_flow, t, start);
                if (temp_flow > 0) {
                    e.flow += temp_flow;
                    adj[e.v][e.rev].flow -= temp_flow;
                    return temp_flow;
                }
            }
        }
        return 0;
    }

    int DinicMaxflow(int s, int t) {
        if (s == t)
            return -1;
        int total = 0;
        while (BFS(s, t)) {
            int *start = new int[V + 1];
            while (int flow = sendFlow(s, INT_MAX, t, start))
                total += flow;
        }
        return total;
    }

};

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

int main() {
    int N, M;
    ios::sync_with_stdio(false);
    in.tie(nullptr);
    in >> N >> M;
    Graph g(N + 2);
    for (int i = 1; i <= M; ++i) {
        int x, y, c;
        in >> x >> y >> c;
        g.addEdge(x, y, c);
    }
    out << g.DinicMaxflow(1, N) << '\n';
    return 0;
}