#include <bits/stdc++.h>

using namespace std;

struct Graph
{
    static const int N = 1005;
    int n, src, dst;
    vector<vector<long long>> cap;
    vector<vector<int>> adj;
    bool vis[N];
    int parent[N];
    queue<int> q;

    Graph(int n) : n(n), adj(n),
        cap(n, vector<long long>(n, 0)) {}

    void AddEdge(int a, int b, int c)
    {
        adj[a].push_back(b);
        adj[b].push_back(a);
        cap[a][b] += c;
    }

    bool ek_iter()
    {
        fill(vis,vis + n,false);
        fill(parent, parent + n,-1);
        q.push(src);
        vis[src] = true;
        while(!q.empty())
        {
            int node = q.front();
            q.pop();
            for(auto nei : adj[node])
            {
                if(vis[nei] || !cap[node][nei])
                    continue;
                vis[nei] = true;
                parent[nei] = node;
                if(nei != dst)
                    q.push(nei);
            }

        }
        return vis[dst] > 0;
    }


    long long FordFulkerson(int src, int dst)
    {
        this->src = src;
        this->dst = dst;
        long long max_flow = 0;
        while (ek_iter())
        {
            for(auto nei : adj[dst])
            {
                if(!cap[nei][dst] && !vis[nei])
                    continue;
                parent[dst] = nei;
                int current_flow = 2e18;
                for (int node = dst; node != src; node = parent[node])
                        if(current_flow > cap[parent[node]][node])
                            current_flow = cap[parent[node]][node];
                if(current_flow == 0)
                    continue;
                for (int node = dst; node != src; node = parent[node])
                {
                    cap[parent[node]][node] -= current_flow;
                    cap[node][parent[node]] += current_flow;
                }
                max_flow += current_flow;
            }
        }
        return max_flow;
    }
};

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

    int n, m;
    cin >> n >> m;
    Graph G(n);
    for (int i = 0; i < m; ++i)
    {
        int a, b, c;
        cin >> a >> b >> c;
        --a;
        --b;
        G.AddEdge(a, b, c);
    }

    auto answer = G.FordFulkerson(0, n - 1);
    cout << answer << '\n';

    return 0;
}