#include <bits/stdc++.h>
#define INF 0x3f3f3f3f

using namespace std;

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

int N;
vector < vector < int > > Capacity, Flow, Graph;
vector < bool > viz;

inline void min_self(int& a, int b) {
    a = min(a, b);
}

bool BFS(int source, int sink, vector < int >& parent) {
    queue < int > Q;
    Q.emplace(source);
    viz.assign(N + 1, false);
    viz[source] = true;
    while(!Q.empty()) {
        int curr = Q.front();
        Q.pop();
        if(curr == sink)
            continue;
        for(int next : Graph[curr])
            if(!viz[next] && Capacity[curr][next] > Flow[curr][next]) {
                parent[next] = curr;
                viz[next] = true;
                Q.emplace(next);
            }
    }
    return viz[sink];
}

int max_flow(int source, int sink) {
    int flow = 0;
    vector < int > parent(N + 1);
    int cnt = 0;
    while(BFS(source, sink, parent))
        for(int prev : Graph[sink])
            if(viz[prev] && Capacity[prev][sink] > Flow[prev][sink]) {
                parent[sink] = prev;
                int new_flow = INF;
                for(int node = sink; node != source; node = parent[node])
                    min_self(new_flow, Capacity[parent[node]][node] - Flow[parent[node]][node]);
                if(new_flow == 0)
                    continue;
                flow += new_flow;
                for(int node = sink; node != source; node = parent[node])  {
                    Flow[parent[node]][node] += new_flow;
                    Flow[node][parent[node]] -= new_flow;
                }
            }
    return flow;
}

int main() {
    fin.sync_with_stdio(false);
    fout.sync_with_stdio(false);
    fin.tie(nullptr);
    fout.tie(nullptr);
    int M;
    fin >> N >> M;
    Capacity = Flow = vector < vector < int > >(N + 1, vector < int >(N + 1));
    Graph.resize(N + 1);
    while(M--) {
        int u, v, w;
        fin >> u >> v >> w;
        Capacity[u][v] += w;
        Graph[u].emplace_back(v);
        Graph[v].emplace_back(u);
    }
    fout << max_flow(1, N);
}