#include <cstdio>
#include <deque>
#include <vector>
#include <algorithm>
#include <bitset>

#define DIM 1024
using namespace std;

int nrNodes, nrEdges, node1, node2, cost;

vector <int> Edges[DIM]; int Father[DIM];
bitset <DIM> Marked; deque <int> Queue;
int Quantity[DIM][DIM], maxFlow[DIM][DIM];

bool BFS (int startNode, int finishNode)
{
    Marked.reset();
    Queue.clear();

    int ok = 0;
    Queue.push_back(startNode);
    Marked[startNode] = 1;

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

        vector <int> :: iterator it;
        for (it = Edges[node].begin(); it != Edges[node].end(); it ++)
        {
            int nextNode = *it;

            if (!Marked[nextNode] && maxFlow[node][nextNode] < Quantity[node][nextNode])
            {
                Marked[nextNode] = 1;
                Father[nextNode] = node;
                Queue.push_back(nextNode);

                if (nextNode == finishNode)
                    ok = 1;
            }
        }

        Queue.pop_front();
    }

    return ok;
}

int main ()
{
    freopen ("maxflow.in" ,"r", stdin );
    freopen ("maxflow.out","w", stdout);

    scanf ("%d %d", &nrNodes, &nrEdges);

    for (int i = 1; i <= nrEdges; i ++)
    {
        scanf ("%d %d %d", &node1, &node2, &cost);

        Quantity[node1][node2] = cost;
        Edges[node1].push_back(node2);
        Edges[node2].push_back(node1);
    }

    int sum = 0;
    while ( BFS(1, nrNodes) )
    {
        int node = nrNodes;

        vector <int> :: iterator it;
        for (it = Edges[node].begin(); it != Edges[node].end(); it ++)
        {
            int nextNode = *it;

            if (Marked[nextNode] && maxFlow[nextNode][node] < Quantity[nextNode][node])
            {
                int minim = Quantity[nextNode][node] - maxFlow[nextNode][node], newNode;

                newNode = nextNode;
                while (Father[newNode])
                {
                    minim = min (minim, Quantity[Father[newNode]][newNode] - maxFlow[Father[newNode]][newNode]);
                    newNode = Father[newNode];
                }

                sum += minim;
                maxFlow[nextNode][node] += minim;
                maxFlow[node][nextNode] -= minim;

                newNode = nextNode;
                while (Father[newNode])
                {
                    maxFlow[Father[newNode]][newNode] += minim;
                    maxFlow[newNode][Father[newNode]] -= minim;
                    newNode = Father[newNode];
                }
            }
        }
    }

    printf ("%d\n", sum);

    fclose (stdin );
    fclose (stdout);

    return 0;
}