#include <bits/stdc++.h>

using namespace std;

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

struct Flux
{
    struct Edge
    {
        int from, to, cap, ult;
    };
    vector <Edge> edges;
    vector <int> last, dist;
    queue <int> coada;
    int n;

    Flux(int cn)
    {
        n = cn;
        last.assign(n + 1, -1);
    }


    void baga(int from, int to, int cap)
    {
        edges.push_back({from, to, cap, last[from]});
        last[from] = edges.size() - 1;

        edges.push_back({to, from, 0, last[to]});
        last[to] = edges.size() - 1;
    }

    bool bfs(int sursa, int destinatie)
    {
        dist.assign(n + 1, 1e9);
        dist[sursa] = 0;
        coada.push(sursa);

        while(!coada.empty())
        {
            int x = coada.front();
            coada.pop();
            for(int y = last[x]; y != -1; y = edges[y].ult)
            {
                if(edges[y].cap > 0 && dist[edges[y].to] == 1e9)
                {
                    dist[edges[y].to] = dist[x] + 1;
                    coada.push(edges[y].to);
                }
            }
        }

        return (dist[destinatie] != 1e9);
    }



    int dfs(int sursa, int destinatie, int maxflux)
    {
        if(sursa == destinatie)
            return maxflux;
        int ans = 0;
        for(int y = last[sursa]; y != -1; y = edges[y].ult)
        {
            if(edges[y].cap > 0 && dist[edges[y].to] == (dist[sursa] + 1))
            {
                int trimis = dfs(edges[y].to, destinatie, min(maxflux, edges[y].cap));

                edges[y].cap -= trimis;
                edges[y ^ 1].cap += trimis;

                maxflux -= trimis;
                ans += trimis;
            }
        }
        return ans;
    }


    int MaxFlow(int sursa, int destinatie)
    {
        int ans = 0;
        while(bfs(sursa, destinatie))
            ans += dfs(sursa, destinatie, 1e9);
        return ans;
    }
};


int main()
{
    int n, m;
    in >> n >> m;
    Flux x(n);
    for(int i = 0; i < m; i++)
    {
        int from, to, cap;
        cin >> from >> to >> cap;
        x.baga(from, to, cap);
    }
    out << x.MaxFlow(1, n);
}