#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;

            if(nextNode == verticesNumber) return true;

            visited[currentNode] = true;

            nodeQueue.push(nextNode);
        }
    }

    return false;
}


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())
    {
        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;

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

    fout << maxFlow;
}