#include <fstream>

#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#if __cplusplus > 199711L
#include <unordered_map>
#include <unordered_set>
#endif

#include <cmath>
#include <cstring>
#include <cstdlib>

using namespace std;

const int inf = 0x3f3f3f3f;

int N, M;
int C[1010][1010], F[1010][1010], TT[1010];
vector<int> Graph[1010];
bool visited[1010];

bool BFS();

int main()
{
	ifstream fin("maxflow.in");
	ofstream fout("maxflow.out");

	int i, x, y, flow, fmin, node;
	vector<int>::iterator it;

	fin >> N >> M;

	while(M--)
    {
        fin >> x >> y;
        fin >> C[x][y];
        Graph[x].push_back(y);
        Graph[y].push_back(x);
    }

    for (flow = 0; BFS(); )
    {
        for (it = Graph[N].begin(); it != Graph[N].end(); ++it)
        {
            node = *it;
            if (C[TT[node]][node] == F[TT[node]][node] || !visited[node]) continue;
            TT[N] = node;
            fmin = inf;
            for (i = ; i != 1; i = TT[i])
                fmin = min(fmin, C[TT[i]][i] - F[TT[i]][i]);
            if (fmin == 0) continue;
            for (i = N; i != 1; i = TT[i])
                F[i][TT[i]] = -(F[TT[i]][i] += fmin);
            flow += fmin;
        }
    }

    fout << flow << '\n';
	fout.close();
    return 0;
}

bool BFS()
{
    int node, _node;
    vector<int>::iterator it;
    queue<int> Q;

    memset(visited, 0, sizeof(visited));
    visited[1] = true;
    Q.push(1);

    while(!Q.empty())
    {
        node = Q.front();
        Q.pop();

        for (it = Graph[node].begin(); it != Graph[node].end(); ++it)
        {
            _node = *it;
            if (C[node][_node] == F[node][_node] || visited[_node]) continue;
            visited[_node] = true;
            Q.push(_node);
            TT[_node] = node;
        }
    }

    return visited[N];
}