#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];
deque<int> q;

inline bool BFS() {
    q.clear();
    int currNode = -1;

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

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

    while (!q.empty() && currNode != numVert) {
        currNode = q.front();
        q.pop_front();

        if (currNode == numVert) {
            return true;
        }

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

    return false;
}

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;

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