#include <fstream>
#include <vector>
#include <limits.h>
#include <queue>

using namespace std;

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

const int NMAX = 1e3 + 1;
int c[NMAX][NMAX];
int n, m;

struct FlowEdge
{
    int u;
    long long cap, flow = 0;
    long long &residual;
    FlowEdge(int u, long long cap) : u(u), cap(cap), residual{flow} {}
};

vector<FlowEdge> g[NMAX];
vector<int> lvl;

bool BFS()
{
    lvl = vector<int>(n + 1, -1);
    lvl[1] = 0;
    queue<int> q;
    q.push(1);

    while (!q.empty())
    {
        int crt = q.front();
        q.pop();
        for (auto x : g[crt])
        {
            if (x.cap == x.flow || lvl[x.u] != -1)
                continue;
            lvl[x.u] = lvl[crt] + 1;
            q.push(x.u);
        }
    }
    return lvl[n] != -1;
}

long long DFS(int x, long long pushed)
{
    if (pushed == 0 || x == n)
        return pushed;

    for (auto &y : g[x])
    {
        if (lvl[y.u] != lvl[x] + 1)
            continue;
        long long tr = DFS(y.u, min(pushed, y.cap - y.flow));
        if (tr == 0)
            continue;
        y.flow += tr;
        y.residual -= tr;
        return tr;
    }
    return 0;
}

long long maxFlow()
{
    long long f = 0;
    while (true)
    {
        if (!BFS())
            return f;
        while (long long pushed = DFS(1, INT_MAX))
            f += pushed;
    }
    return f;
}

int main()
{
    int x, y, c;
    fin >> n >> m;
    for (int i = 1; i <= m; ++i)
    {
        fin >> x >> y >> c;
        g[x].push_back({y, c});
        g[y].push_back({x, 0});
        g[x].back().residual = g[y].back().flow;
        g[y].back().residual = g[x].back().flow;
    }
    fout << maxFlow() << '\n';
    return 0;
}