#include <fstream>
#include <vector>
#include <queue>


using namespace std;


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


const int N_MAX = 1000 + 1;

int N, M;
vector<vector<int>> graph(N_MAX, vector<int>());

int C[N_MAX][N_MAX], F[N_MAX][N_MAX], parent[N_MAX];


bool BFS(int source, int sink)
{
    queue<int> node_queue;

    fill(parent + 1, parent + N + 1, -1);

    parent[source] = 0;
    node_queue.push(source);

    while (node_queue.empty() == false)
    {
        int node = node_queue.front();
        node_queue.pop();

        if (node == sink) continue;

        for (int next : graph[node])
        {
            if (C[node][next] == F[node][next] || parent[next] != -1) continue;

            node_queue.push(next);
            parent[next] = node;
        }
    }

    return (parent[sink] != -1);
}


int main()
{
    fin >> N >> M;

    for (int x, y, c, i = 1; i <= M; ++i)
    {
        fin >> x >> y >> c;

        graph[x].push_back(y);
        graph[y].push_back(x);

        C[x][y] = c;
    }

    int source = 1;
    int sink = N;

    long long max_flow = 0;

    while (BFS(source, sink))
    {
        for (auto& possible_parent : graph[sink])
        {
            if (parent[possible_parent] == -1 || C[possible_parent][sink] == F[possible_parent][sink]) continue;

            parent[sink] = possible_parent;

            int augument_flow = 1e9;

            for (int node = sink; node != source; node = parent[node])
                augument_flow = min(augument_flow, C[parent[node]][node] - F[parent[node]][node]);

            if (augument_flow == 0) continue;

            for (int node = sink; node != source; node = parent[node])
            {
                F[parent[node]][node] += augument_flow;
                F[node][parent[node]] -= augument_flow;
            }

            max_flow += augument_flow;
        }
    }

    fout << max_flow;
}