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

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

int n, m = 0;
constexpr int nmax = 1001;
const long long inf = 1e17;
struct edge
{
    int u, v;
    long long ca, f;

    edge( int u, int v, long long ca ): u(u), v(v), ca(ca) {}
};

std::vector<edge> e;
std::vector<int> j[nmax];
int h[nmax], ptr[nmax];

void Add(int u, int v, long long ca)
{
  e.emplace_back(u, v, ca);
  e.emplace_back(v, u, 0);
  j[u].emplace_back(m);
  j[v].emplace_back(m + 1);
  m += 2;
}

bool bfs(int s, int t)
{
    for ( int i = 0; i <= n; ++i )
        h[i] = -1, ptr[i] = 0;
    h[s] = 0;
    std::queue<int> q;
    q.emplace(s);

    while ( !q.empty() )
    {
        int u = q.front();
        q.pop();
        for ( auto id : j[u] )
        {
            int v = e[id].v;
            if ( h[v] != -1 )
                continue;
            if ( e[id].ca - e[id].f < 1 )
                continue;
            h[v] = h[u] + 1;
            q.push(v);
        }
    }

    return h[t] != -1;
}

long long dfs(int s, int t, int u, long long pushed )
{
    if ( pushed == 0 or u == t )
        return pushed;
    for ( int& cid = ptr[u]; cid < j[u].size(); ++cid )
    {
        int id = j[u][cid];
        int v = e[id].v;
        if ( h[u] + 1 != h[v] )
            continue;
        if ( e[id].ca - e[id].f < 1 )
            continue;
        int d = dfs(s, t, v, std::min(pushed, e[id].ca - e[id].f ));
        if ( d == 0 )
            continue;
        e[id].f += d;
        e[id ^ 1].f -= d;
        return d;
    }
    return 0;
}

long long fm(int s, int t)
{

    long long flow = 0;
    while ( bfs(s, t) )
        flow += dfs(s, t, s, inf);
    return flow;
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    in.tie(0);
    in >> n;
    int mm;
    in >> mm;
    for ( int i = 1; i <= mm; ++i )
    {
        int a, b, c;
        in >> a >> b >> c;
        Add(a, b, c);
    }
    out << fm(1, n);
    return 0;
}