#include <bits/stdc++.h>

using namespace std;

struct Dinic
{
    struct Edge
    {
        int x, y, cap, f;
    };

    int n;
    vector<Edge> e;
    vector<vector<int>> g;
    vector<bool> inD, blocked;
    vector<int> d;

    void init(int N)
    {
        n = N;
        g.resize(n + 1);
        d.resize(n + 1);
        blocked.resize(n + 1);
    }

    void baga(int x, int y, int cap)
    {
        Edge aux;
        aux.x = x, aux.y = y, aux.cap = cap, aux.f = 0;
        g[x].push_back(e.size());
        e.push_back(aux);
        swap(aux.x, aux.y);
        aux.cap = 0;
        g[y].push_back(e.size());
        e.push_back(aux);
    }

    bool bfs(int s, int t)
    {
        for (int i = 1; i <= n; i++)
            d[i] = 1e9;
        inD.resize(e.size());
        for (int i = 0; i < e.size(); i++)
            inD[i] = false;
        d[s] = 0;
        queue<int> q;
        q.push(s);
        while (!q.empty())
        {
            int nod = q.front();
            q.pop();
            for (auto vecin : g[nod])
            {
                if (e[vecin].f != e[vecin].cap and d[e[vecin].y] > 1 + d[nod])
                {
                    d[e[vecin].y] = 1 + d[nod];
                    q.push(e[vecin].y);
                }
                if (e[vecin].f != e[vecin].cap and d[e[vecin].y] == 1 + d[nod])
                    inD[vecin] = true;
            }
        }
        if (d[t] != (int)1e9)
            return true;
        return false;
    }

    int dfs(int s, int t, int F)
    {
        //cout << s << ' ' << F << endl;
        if (s == t)
            return F;
        int flow_pushed = 0;
        bool all_blocked = true;
        for (auto vecin : g[s])
        {
            if (!inD[vecin])
                continue;
            if (e[vecin].cap != e[vecin].f and !blocked[e[vecin].y])
            {
                int df = dfs(e[vecin].y, t, min(F, e[vecin].cap - e[vecin].f));
                flow_pushed += df;
                //cout << df << endl;
                F -= df;
                e[vecin].f += df;
                e[vecin ^ 1].f -= df;
            }
            if (e[vecin].cap != e[vecin].f and !blocked[e[vecin].y])
                all_blocked = false;
        }
        if (all_blocked or flow_pushed == 0)
            blocked[s] = true;
        return flow_pushed;
    }

    int maxFlow(int s, int t)
    {
        int ans = 0;
        while (bfs(s, t))
        {
            for (int i = 1; i <= n; i++)
                blocked[i] = false;
            ans += dfs(s, t, 1e9);
        }
        return ans;
    }
};

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

int main()
{
    Dinic ds;
    int n, m;
    in >> n >> m;
    ds.init(n);
    for (int i = 1; i <= m; i++)
    {
        int x, y, z;
        in >> x >> y >> z;
        ds.baga(x, y, z);
    }
    out << ds.maxFlow(1, n);
    return 0;
}