#include <bits/stdc++.h>
	
using namespace std;
	
//#pragma GCC optimize ("O3")
	
//#pragma GCC target ("sse4")
	
#define endl "\n"
	
#define pb push_back
	
typedef int ll;
	
typedef long double ld;
	
typedef unsigned long long ull;
	
const ll mod = 1e9 + 7, inf = 1e18;
	
 
	
 
	
const ll MAX_N = 1e3 + 10;
	
struct Edge {
	
    ll to;
    ull cap, f;
	
    Edge(ll to, ll cap) : to(to), cap(cap), f(0) {}
	
};
	
 
	
struct Dinic {
	
    ll s, t, n, m;
	
    //vector<ll> dist, g[MAX_N], id;
	ll dist[MAX_N], id[MAX_N];
	std::vector<ll> g[MAX_N];
	int edges_cnt = 0;
    vector<Edge> edges;
	
    //Dinic(ll s, ll t, ll n) : s(s), t(t), n(n) {dist.resize(n); id.resize(n);}
	Dinic(ll s, ll t, ll n) {
		this->s = s;
		this->t = t;
		this->n = n;
	}
	
    void addEdge(ll a, ll b, ll cap) {
	
        g[a].push_back(edges.size());
	
        edges.emplace_back(b, cap);
	
        g[b].push_back(edges.size());
	
        edges.emplace_back(a, 0);
	
    }
	
    bool bfs() {
	
        //for(ll i = 0; i < n; i ++) {dist[i] = -1; id[i] = 0;}
        std::fill(dist, dist + n, -1);
        std::fill(id, id + n, 0);

	
        queue<ll> q;
	
        q.push(s);
	
        dist[s] = 0;
	
        while(!q.empty()) {
	
            ll curr = q.front(); q.pop();
	
            for(auto id : g[curr]) {
	
                if(dist[edges[id].to] != -1 || edges[id].cap - edges[id].f < 1) {continue;}
	
                dist[edges[id].to] = dist[curr] + 1;
	
                q.push(edges[id].to);
	
            }
	
        }
	
        return dist[t] != -1;
	
    }
	
    ull dfs(ll curr, ull pushed) {
	
        if(pushed == 0 || curr == t) {return pushed;}
	
        for(; id[curr] < g[curr].size();) {
	
            int nxt = g[curr][id[curr] ++];
	
            if(dist[edges[nxt].to] != dist[curr] + 1 || edges[nxt].cap - edges[nxt].f < 1) {continue;}
	
            ll tr = dfs(edges[nxt].to, min(edges[nxt].cap - edges[nxt].f, pushed));
	
            if(tr != 0) {
	
                edges[nxt].f += tr;
	
                edges[nxt ^ 1].f -= tr;
	
                return tr;
	
            }
	
        }
	
        return 0;
	
    }
	
    ll callDfs() {
	
        //for(ll i = 0; i < n; i ++) {id[i] = 0;}
        std::fill(id, id + n, 0);
	
        return dfs(s, inf);
	
    }
	
    ull maxFlow() {
	
        ull ret = 0;
	
        while(bfs()) {
	
            ull p;
	
            while(p = callDfs()) {
	
                ret += p;
	
            }
	
        }
	
        return ret;
	
    }
	
};
	
int main() {
	
    //ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
	
    ofstream myfile;
	
    myfile.open ("maxflow.out");
	
    ifstream myFileIn;
	
    myFileIn.open ("maxflow.in");
	
 
	
    ll n, m;
	
    myFileIn >> n >> m;
	
    Dinic dc(1, n, n + 1);
	
    for(ll i = 0; i < m; i ++) {
	
        ll a, b, cap;
	
        myFileIn >> a >> b >> cap;
	
        dc.addEdge(a, b, cap);
	
    }
	
    myfile << dc.maxFlow() << endl;
	
    return 0;
	
}