#include <fstream>
#include <vector>
#include <queue>

using namespace std;
ifstream cin("maxflow.in");
ofstream cout("maxflow.out");
int INF=1e9;
class Dinic {
private:

    struct Edge {
        long long from, to, cap, nxt;
    };

    long long s, t;
    long long n;
    vector <long long> lev, rem, graph;
    vector <Edge> edges;

public:

    Dinic (long long n, long long s, long long t) : n(n), s(s), t(t)
    {
        edges.clear();
        lev.clear();
        rem.clear();
        graph.clear();
        graph.resize(1 + n, -1);
        lev.resize(1 + n);
        rem.resize(1 + n);
    }

    void addEdge (long long from, long long to, long long w) {
        edges.push_back(Edge {from, to, w, graph[from]});
        graph[from] = edges.size() - 1;

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

    bool bfs() {
        fill (lev.begin(), lev.end(), 0);

        queue <long long> q;
        q.push(s);
        lev[s] = 1;

        while (!q.empty()) {
            long long from = q.front();
            q.pop();

            for (long long i = graph[from]; i != -1; i = edges[i].nxt) {
                Edge e = edges[i];

                if (e.cap && lev[e.to] == 0) {
                    lev[e.to] = 1 + lev[e.from];
                    q.push(e.to);
                }
            }
        }

        return (lev[t] > 0);
    }

    long long dfs (long long node, long long need) {
        if (need == 0) return 0;
        if (node == t) return need;

        long long curr_flow = 0;

        for (long long &it = rem[node]; it != -1; it = edges[it].nxt) {
            Edge e = edges[it];

            if (lev[e.to] == 1 + lev[node] && e.cap > 0) {
                long long flow = dfs (e.to, min (need , e.cap));

                edges[it].cap -= flow;
                edges[it ^ 1].cap += flow;

                curr_flow += flow;
                need -= flow;

                if (need == 0)
                    break;
            }
        }

        return curr_flow;
    }

    long long maxFlow() {
        long long ans = 0;

        while (bfs() == true) {
            rem = graph;

            ans += dfs (s, INF);
        }

        return ans;
    }
};
int main()
{
   int n,i,j,k,w,m,a,b;
   cin>>n>>m;
   Dinic graf(n+1,1,n);
   for(i=1;i<=m;i++)
   {
       cin>>a>>b>>w;
       graf.addEdge(a,b,w);
   }
   cout<<graf.maxFlow();
    return 0;
}