#include <bits/stdc++.h>

using namespace std;

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

const int maxN = 1005;
const int INF = 1e18;

int parent[maxN], a[maxN][maxN];

vector <int> g[maxN];

int bfs (int source, int sink) {

    for(int i = source; i <= sink; ++i)
        parent[i] = 0;

    queue <pair<int,int>> q;

    parent[source] = -1;
    q.push({source, INF});

    while(!q.empty()) {
        int node = q.front().first;
        int flow = q.front().second;

        q.pop();

        if(node == sink)
            continue ;

        for(int to : g[node])
            if(parent[to] == 0 && a[node][to] > 0) {
                int newFlow = min(flow, a[node][to]);

                parent[to] = node;

                q.push({to, newFlow});
            }
    }

    return parent[sink];
}

int maxFlow (int source, int sink) {

    int flow = 0;

    while(bfs(source, sink))
        for(int prev : g[sink]) {

            if(parent[prev] == 0 || a[prev][sink] <= 0)
                continue ;

            parent[sink] = prev;
            int newFlow = INF;

            int to = sink;
            while(to != source) {
                int node = parent[to];
                newFlow = min(newFlow, a[node][to]);
                to = node;
            }

            to = sink;
            while(to != source) {
                int node = parent[to];

                a[to][node] += newFlow;
                a[node][to] -= newFlow;

                to = node;
            }

            flow += newFlow;

        }

    return flow;
}

signed main() {

    int n, m; fin >> n >> m;

    for(int i = 1; i <= m; ++i) {
        int u, v, c; fin >> u >> v >> c;

        g[u].push_back(v);
        g[v].push_back(u);

        a[u][v] += c;
    }

    int flow = maxFlow(1, n);

    fout << flow;

    return 0;
}