#include <bits/stdc++.h>
#define NMAX 1001
#define oo 2000000000
using namespace std;


ifstream fin("maxflow.in");

ofstream fout("maxflow.out");

int verticesNumber, edgesNumber, maxFlow = 0;

vector<vector<int>> graph(NMAX, vector<int>());

vector<vector<int>> capacities(NMAX, vector<int>(NMAX, 0));

vector<vector<int>> flow(NMAX, vector<int>(NMAX, 0));

vector<int> visited(NMAX);

vector<int> previous(NMAX);


bool breadthFirstSearch()
{
    fill(visited.begin(), visited.end(), false);

    queue<int> nodeQueue;

    nodeQueue.push(1);

    visited[1] = true;

    while(!nodeQueue.empty())
    {
        int currentNode = nodeQueue.front();

        nodeQueue.pop();

        for(auto& nextNode : graph[currentNode])
        {
            if(capacities[currentNode][nextNode] == flow[currentNode][nextNode] || visited[nextNode]) continue;

            previous[nextNode] = currentNode;

            visited[nextNode] = true;

            nodeQueue.push(nextNode);
        }
    }

    return visited[verticesNumber];
}


int main()
{
    fin >> verticesNumber>> edgesNumber;

    for(int i = 1; i <= edgesNumber; ++i)
    {
        int vertex1, vertex2, capacity;

        fin >> vertex1 >> vertex2 >> capacity;

        graph[vertex1].push_back(vertex2);
        graph[vertex2].push_back(vertex1);

        capacities[vertex1][vertex2] = capacity;
    }


    while(breadthFirstSearch())
    {
        for(auto& previousNode : graph[verticesNumber])
        {
            if(!visited[previousNode] || capacities[previousNode][verticesNumber] == flow[previousNode][verticesNumber]) continue;

            previous[verticesNumber] = previousNode;

            int minCapacity = oo;

            for(int node = verticesNumber; node != 1; node = previous[node])
                minCapacity = min(minCapacity,capacities[previous[node]][node] - flow[previous[node]][node]);

            maxFlow += minCapacity;

            if(minCapacity == 0) continue;

            for(int node = verticesNumber; node != 1; node = previous[node])
            {
                flow[previous[node]][node] += minCapacity;
                flow[node][previous[node]] -= minCapacity;
            }
        }
    }

    fout << maxFlow;
}