#include <fstream>
#include <vector>
#include <queue>
using namespace std;

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

const int N = 1000;
const int INF = 110000 + 1;

int adj[N + 1][N + 1];
int n, m;
vector<int> par(N + 1, 0);
vector<int> v[N];

void bfs()
{
    queue<int> q;

    for(int i = 1; i <= n; ++i)
        par[i] = 0;

    q.push(1);
    par[1] = -1;

    //coada este goala si nu a fost gasit drum catre destinatie
    while(!q.empty() && !par[n])
    {
        int curr = q.front();
        q.pop();
        for(auto nbh: v[curr])
        {
            // mai poate fi pompat flux si nodul nu a fost vizitat
            if(adj[curr][nbh] && !par[nbh])
            {
                par[nbh] = curr;
                q.push(nbh);
            }
        }

    }
}

int ford_fulkerson()
{
    int ans = 0;
    while(true)
    {
        bfs();
        //nu a fost gasit drum
        if(par[n] == 0)
            return ans;
        else
        {
                for(auto nbh: v[n])
                {
                    int curr = n;
                    par[n] = nbh;
                    if(par[nbh] > 0)
                    {
                        int flow = INF;
                        //bottleneck
                        while(par[curr] != -1)
                        {
                            flow = min(flow, adj[par[curr]][curr]);
                            curr = par[curr];
                        }
                        curr = n;
                        //update flux
                        while(par[curr] != -1)
                        {
                            adj[par[curr]][curr] -= flow;
                            adj[curr][par[curr]] += flow;
                            curr = par[curr];
                        }
                        ans += flow;
                    }
                }
        }
    }
}
int main()
{
    in >> n >> m;
    for(int i = 0; i < m ; ++i)
    {
        int a, b, c;
        in >> a >> b >> c;
        adj[a][b] = c;
        v[a].push_back(b);
        v[b].push_back(a);
    }
    out << ford_fulkerson();
    return 0;
}