#include <bits/stdc++.h>

using namespace std;

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

struct Dinic
{
    struct Edge
    {
        int to, rev;
        long long cap;
    };

    int n;
    vector<vector<Edge>> g;
    vector<int> level, it;

    Dinic(int n) : n(n), g(n + 1), level(n + 1), it(n + 1)
    {
    }

    void add_edge(int u, int v, long long c)
    {
        Edge a{v, (int)g[v].size(), c};
        Edge b{u, (int)g[u].size(), 0};
        g[u].push_back(a);
        g[v].push_back(b);
    }

    bool bfs(int s, int t)
    {
        fill(level.begin(), level.end(), -1);
        queue<int> q;
        level[s] = 0;
        q.push(s);

        while (!q.empty())
        {
            int u = q.front();
            q.pop();
            for (auto& e : g[u])
            {
                if (e.cap > 0 && level[e.to] == -1)
                {
                    level[e.to] = level[u] + 1;
                    q.push(e.to);
                }
            }
        }
        return level[t] != -1;
    }

    long long dfs(int u, int t, long long f)
    {
        if (u == t) return f;
        for (int& i = it[u]; i < g[u].size(); i++)
        {
            Edge& e = g[u][i];
            if (e.cap > 0 && level[e.to] == level[u] + 1)
            {
                long long pushed = dfs(e.to, t, min(f, e.cap));
                if (pushed > 0)
                {
                    e.cap -= pushed;
                    g[e.to][e.rev].cap += pushed;
                    return pushed;
                }
            }
        }
        return 0;
    }

    long long maxflow(int s, int t)
    {
        long long flow = 0;
        const long long INF = (1LL << 62);
        while (bfs(s, t))
        {
            fill(it.begin(), it.end(), 0);
            while (true)
            {
                long long pushed = dfs(s, t, INF);
                if (!pushed) break;
                flow += pushed;
            }
        }
        return flow;
    }
};

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

    Dinic dinic(n);
    for (int i = 0; i < m; i++)
    {
        int x, y;
        long long z;
        fin >> x >> y >> z;
        dinic.add_edge(x, y, z);
    }

    fout << dinic.maxflow(1, n) << "\n";
    return 0;
}