#include <bits/stdc++.h>

using namespace std;

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

vector<int> g[1005];
int n, m;
vector<pair<int, pair<long long, long long>>> edges;
int prev_edge[1005];
int from[1005];

void bfs()
{
    queue<int> q;

    q.push(1);
    for(int i = 1; i <= n; i++) { prev_edge[i] = -1; from[i] = 0; }

    while(!q.empty())
    {
        int node = q.front(); q.pop();

        for(int i = 0; i < g[node].size(); i++)
        {
            auto edge = edges[g[node][i]];
            if(prev_edge[edge.first] == -1 && edge.first != 1 && edge.second.first < edge.second.second)
            {
                prev_edge[edge.first] = g[node][i];
                from[edge.first] = node;
                q.push(edge.first);
            }
        }
    }
}

long long flow = 0;

long long update_at_index(int ind, long long max_update)
{
    if(prev_edge[ind] != -1)
    {
        long long df = max_update;
        //cout << max_update << endl;

        for(int index = ind; index != 0; index = from[index])
        {
            int edge_index = prev_edge[index];
            if(edge_index != -1)
                df = min(df, edges[edge_index].second.second - edges[edge_index].second.first);
        }

        for(int index = ind; index != 0; index = from[index])
        {
            int edge_index = prev_edge[index];
            if(edge_index != -1)
            {
                edges[edge_index].second.first += df;
                edges[edge_index ^ 1].second.first = edges[edge_index ^ 1].second.first - df;
            }
        }

        //cout << df << endl;

        flow += df;
        return df;
    }
    return 0;
}

long long EdmondsKarp()
{
    do
    {
        bfs();

        /*cout << "A" << endl;
        cout << flow << endl;*/


        if(prev_edge[n] != -1)
        {
            for(int i = 0; i < g[n].size(); i++)
            {
                long long df = update_at_index(edges[g[n][i]].first, edges[g[n][i] ^ 1].second.second - edges[g[n][i] ^ 1].second.first);
                edges[g[n][i] ^ 1].second.first += df;
                edges[g[n][i]].second.first -= df;
            }
        }

    } while(prev_edge[n] != -1);

    return flow;
}

int main()
{
    in >> n >> m;

    for(int i = 0; i < m; i++)
    {
        int x, y; long long cap; in >> x >> y >> cap;

        g[x].push_back(edges.size());
        g[y].push_back(edges.size() + 1);

        edges.push_back(make_pair(y, make_pair(0, cap)));
        edges.push_back(make_pair(x, make_pair(0, 0LL)));
    }

    out << EdmondsKarp();
}