#include <fstream>
#include <queue>
#include <cstring>
#include <climits>

using namespace std;

#define MAX_N 1001

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

bool marked[MAX_N];
int numVert, numEdges, maxFlow, parent[MAX_N], flow[MAX_N][MAX_N];
vector<int> adjList[MAX_N];

inline bool BFS() {
    queue<int> q;
    int currNode;

    memset(marked, 0, sizeof(marked));

    q.push(1);
    marked[1] = true;

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

        if (currNode != numVert) {
            for (int nextNode : adjList[currNode]) {
                if (!marked[nextNode] && flow[currNode][nextNode]) {
                    marked[nextNode] = true;
                    parent[nextNode] = currNode;
                    q.push(nextNode);
                }
            }
        }
    }

    return marked[numVert];
}

int main() {
    int s, t, f, currFlow;

    fIn >> numVert >> numEdges;

    while (numEdges--) {
        fIn >> s >> t >> f;

        adjList[s].push_back(t);
        flow[s][t] += f;

        adjList[t].push_back(s);
    }

    while (BFS()) {
        for (int currNode : adjList[numVert]) {
            if (marked[currNode]) {
                currFlow = INT_MAX;
                parent[numVert] = currNode;

                for (register int i = numVert; i != 1; i = parent[i]) {
                    currFlow = min(currFlow, flow[parent[i]][i]);
                }

                if (currFlow) {
                    for (register int i = numVert; i != 1; i = parent[i]) {
                        flow[parent[i]][i] -= currFlow;
                        flow[i][parent[i]] += currFlow;
                    }

                    maxFlow += currFlow;
                }
            }
        }
    }

    fOut << maxFlow << '\n';

    fIn.close();
    fOut.close();

    return 0;
}