#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <fstream>

using namespace std;

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

const int INF = 1e9;
const int NMAX = 1005;

struct Edge {
    int to;
    int capacity;
    int flow;
    int rev;
};

vector<Edge> adj[NMAX];
int level[NMAX];
int ptr[NMAX];
int N, M;

void add_edge(int from, int to, int cap) {
    Edge forward = {to, cap, 0, (int)adj[to].size()};
    Edge backward = {from, 0, 0, (int)adj[from].size()};
    
    adj[from].push_back(forward);
    adj[to].push_back(backward);
}

bool bfs(int s, int t) {
    fill(level, level + N + 1, -1);
    level[s] = 0;
    queue<int> q;
    q.push(s);
    
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        
        for (const auto& edge : adj[u]) {
            if (edge.capacity - edge.flow > 0 && level[edge.to] == -1) {
                level[edge.to] = level[u] + 1;
                q.push(edge.to);
            }
        }
    }
    return level[t] != -1;
}

int dfs(int u, int t, int pushed) {
    if (pushed == 0) return 0;
    if (u == t) return pushed;
    
    for (int& cid = ptr[u]; cid < adj[u].size(); ++cid) {
        auto& edge = adj[u][cid];
        int tr = edge.to;
        
        if (level[u] + 1 != level[tr] || edge.capacity - edge.flow == 0) continue;
        
        int tr_pushed = dfs(tr, t, min(pushed, edge.capacity - edge.flow));
        
        if (tr_pushed == 0) continue;
        
        edge.flow += tr_pushed;
        adj[tr][edge.rev].flow -= tr_pushed;
        
        return tr_pushed;
    }
    return 0;
}

int dinic(int s, int t) {
    int flow = 0;
    while (bfs(s, t)) {
        fill(ptr, ptr + N + 1, 0);
        while (int pushed = dfs(s, t, INF)) {
            flow += pushed;
        }
    }
    return flow;
}

int main() {
    fin >> N >> M;
    
    for (int i = 0; i < M; ++i) {
        int u, v, cap;
        fin >> u >> v >> cap;
        add_edge(u, v, cap);
    }
    
    fout << dinic(1, N);
    
    fin.close();
    fout.close();
    return 0;
}