#include <bits/stdc++.h>

using namespace std;

struct Edge {
    int to; // nod dest (from e index in lst adiacenta)
    int flow; // cat are in ea
    int cap; // cat poate tine
    int rev; // index muchie inversa in lst adiacenta
};

class Graf {
public:

    int nodeCnt, edgeCnt;
    int *level; //vector nivele
    vector<Edge> *graf;

    Graf(int N, int M) {
        graf = new vector<Edge>[N + 1];
        this->nodeCnt = N;
        this->edgeCnt = M;
        level = new int[nodeCnt + 1];
    }

    void add(int from, int to, int cap) {
        Edge ob1 = {to, 0, cap, static_cast<int>(graf[to].size())};
        Edge ob2 = {from, 0, 0, static_cast<int>(graf[from].size())};
        //inserez front si back edge cu cap corespunzatoare
        graf[from].push_back(ob1);
        graf[to].push_back(ob2);
    }

    bool bfs(int s, int t) {
        /** Calculez nivelele nodurilor*/

        for (int i = 1; i <= nodeCnt; i++)
            level[i] = -1;

        level[s] = 0;

        queue<int> q;
        q.push(s);
        while (!q.empty()) {
            int from = q.front();
            q.pop();

            for (auto &nod:graf[from]) {
                if (level[nod.to] < 0 && nod.flow < nod.cap) {
                    level[nod.to] = level[from] + 1;

                    q.push(nod.to);
                }
            }
        }

        return level[t] > 0;
    }

    int dfs(int from, int flow, int t, int start[]) {
        if (from == t)
            return flow;

        for (; start[from] < graf[from].size(); start[from]++) {
            Edge &m = graf[from][start[from]];
            if (level[m.to] == level[from] + 1 && m.flow < m.cap) {
                int curr_flow = min(flow, m.cap - m.flow);
                int temp_flow = dfs(m.to, curr_flow, t, start);
                if (temp_flow > 0) {
                    m.flow += temp_flow;
                    graf[m.to][m.rev].flow -= temp_flow;
                    return temp_flow;
                }
            }
        }
        return 0;
    }

    int maxflow(int s, int t) {
        if (s == t)
            return -1;

        int total = 0;

        int *start = new int[nodeCnt + 1];
        while (bfs(s, t)) {
            fill(start, start + nodeCnt + 1, 0);
            while (int flow = dfs(s, INT_MAX, t, start))
                total += flow;
        }
        return total;
    }
};

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

int main() {
    int n, m;
    fin >> n >> m;
    Graf gr(n, m);

    for (int i = 1; i <= m; i++) {
        int x, y, c;
        fin >> x >> y >> c;
        gr.add(x, y, c);
    }

    fout << gr.maxflow(1, n);
}