#include <bits/stdc++.h>
using namespace std;

vector <int> v[5005];
long long cap[1005][1005], n, m, x, y, c;
int bfs(int s, int t, vector <int> &p)
{
    deque <pair<int, int>> q;
    fill(p.begin(), p.end(), -1);
    q.push_back({s, 1e9});
    p[s] = 0;
    while(!q.empty())
    {
        long long nod = q.front().first, flow = q.front().second;
        q.pop_front();
        for(int i = 0; i < v[nod].size(); i ++)
        {
            int next = v[nod][i];
            long long capacity = cap[nod][next];
            if(next == t)
            {
                if(capacity)
                    p[next] = nod;
                continue;
            }
            if(p[next] == -1 && capacity)
            {
                long long maxFlow = min(capacity, flow);
                p[next] = nod;
                //if(next == t)
                //  return maxFlow;
                q.push_back({next, maxFlow});
            }
        }
    }
    return p[t] != -1;
}
long long max_flow(int s, int t)
{
    vector <int> p(n + 1);
    long long maxFlow = 0, newFlow = 0;
    while(bfs(s, t, p))
    {
        for(int i = 0; i < v[n].size(); i ++)
        {
            int nod = v[n][i];
            if(!cap[nod][n] || p[nod] == -1) continue;
            newFlow = 1e9;
            p[t] = nod;
            nod = t;

            while(nod != s && newFlow)
            {
                int prev = p[nod];
                newFlow = min(newFlow, cap[prev][nod]);
                nod = prev;
            }
            if(newFlow == 0)
                continue;
            nod = t;
            while(nod != s)
            {
                int prev = p[nod];
                cap[prev][nod] -= newFlow;
                cap[nod][prev] += newFlow;
                nod = prev;
            }
            maxFlow += newFlow;
        }
    }
    return maxFlow;
}
int main()
{
    ifstream f("maxflow.in");
    ofstream g("maxflow.out");

    f >> n >> m;
    for(int i = 1; i <= m; i ++)
    {
        f >> x >> y >> c;
        v[x].push_back(y);
        v[y].push_back(x);
        cap[x][y] = c;
    }
    g << max_flow(1, n);
    return 0;
}