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

using namespace std;

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

int n, m, a, b, c;
int C[1005][1005], F[1005][1005], level[1005], start[1005];
vector<int> G[1005];

bool bfs(int s, int t)
{
    for ( int i = 2; i <= n; i++ )
        level[i] = -1;
    level[s] = 0;

    queue<int> Q;
    Q.push(s);

    while ( !Q.empty() )
    {
        int x = Q.front();
        Q.pop();

        for ( int a : G[x] )
            if ( level[a] < 0 && F[x][a] < C[x][a] )
            {
                level[a] = level[x] + 1;
                Q.push(a);
            }
    }
    return (level[t] > 0);
}

int dfs(int u, int t, int flow)
{
    if ( u == t )
        return flow;

    for ( ; start[u] < G[u].size(); start[u]++ )
    {
        int a = G[u][start[u]];
        if ( level[u] + 1 == level[a] && F[u][a] < C[u][a] )
        {
            int temp_flow = dfs(a, t, min(flow, C[u][a] - F[u][a]));

            if ( temp_flow > 0 )
            {
                F[u][a] += temp_flow;
                F[a][u] -= temp_flow;
                return temp_flow;
            }
        }
    }
    return 0;
}

int Dinic(int s, int t)
{
    int total = 0;

    while ( bfs(s, t) )
    {
        memset(start, 0, sizeof(start));

        while ( int flow = dfs(s, t, INT_MAX) )
            total += flow;
    }

    return total;
}

int main()
{
    fin >> n >> m;

    for ( int i = 1; i <= m; i++ )
    {
        fin >> a >> b >> c;
        C[a][b] += c;
        G[a].push_back(b);
        G[b].push_back(a);
    }

    fout << Dinic(1, n);
}