#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>
#include <chrono>
#include <random>

#define ll long long
#define ld long double

using namespace std;

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

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const int NMAX = 1000;

int n, m, max_flow;
vector<int> g[NMAX + 1];
int capacity[NMAX + 1][NMAX + 1];
int flow[NMAX + 1][NMAX + 1];
int parent[NMAX + 1];

bool BFS(int start) {
    for(int i = 1; i <= n; i++) {
        parent[i] = 0;
    }
    parent[start] = 1;

    queue<int> q;
    q.push(start);
    while(!q.empty()) {
        int node = q.front();
        q.pop();

        for(int next_node : g[node]) {
            if(flow[node][next_node] < capacity[node][next_node] && !parent[next_node]) {
                parent[next_node] = node;
                q.push(next_node);
            }
        }
    }
    return parent[n] != 0;
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> m;
    for(int i = 1; i <= m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        g[a].push_back(b);
        g[b].push_back(a);
        capacity[a][b] += c;
    }

    while(BFS(1)) {
        for(int start_node : g[n]) {
            if(parent[start_node]) {
                int min_flow = capacity[start_node][n] - flow[start_node][n];
                for(int node = start_node; node != 1; node = parent[node]) {
                    min_flow = min(min_flow, capacity[parent[node]][node] - flow[parent[node]][node]);
                }

                max_flow += min_flow;
                flow[start_node][n] += min_flow;
                flow[n][start_node] -= min_flow;
                for(int node = start_node; node != 1; node = parent[node]) {
                    flow[parent[node]][node] += min_flow;
                    flow[node][parent[node]] -= min_flow;
                }
            }
        }
    }
    cout << max_flow;

    return 0;
}