#include <bits/stdc++.h>

using namespace std;

void reset(vector <bool> &v)
{
    for(unsigned i = 0; i < v.size(); i++)
        v[i] = false;
}

void reset(vector <int> &v)
{
    for(unsigned i = 0; i < v.size(); i++)
        v[i] = 0;
}


bool BFS(int start, int dest, vector <vector <int>> &path, vector <vector <int>> &flux, vector <int> &parent, vector <bool> &viz)
{
    reset(viz);
    reset(parent);

    queue <int> q;

    q.push(start);
    viz[start] = true;

    int current, vec;

    while(!q.empty())
    {
        current = q.front();
        q.pop();

        for(unsigned i = 0; i < path[current].size(); i++)
        {
            vec = path[current][i];

            if(!viz[vec] && flux[current][vec] != 0)
            {
                viz[vec] = true;
                q.push(vec);
                parent[vec] = current;

                if(vec == dest)
                {
                    return true;
                }
            }
        }
    }

    return false;
}

void Update(int start, int dest, int &max_flux, vector <vector <int>> &path, vector <vector <int>> &flux, vector <int> &parent, vector <bool> &viz)
{
    int current, vec;

    for(unsigned k = 0; k < path[dest].size(); k++)
    {
        vec = path[dest][k];

        if(viz[vec])
        {
            parent[dest] = vec;
            int min_flux = flux[vec][dest];

            for(current = dest; current != start; current = parent[current])
            {
                min_flux = min(min_flux, flux[parent[current]][current]);
            }

            for(current = dest; current != start; current = parent[current])
            {
                flux[parent[current]][current] -= min_flux;
                flux[current][parent[current]] += min_flux;
            }

            max_flux += min_flux;
        }

    }
}

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

int main()
{
    int n, m;

    fin>>n>>m;

    vector <vector <int>> path(n + 1);
    vector <vector <int>> flux(n + 1, vector <int> (n + 1, 0));
    vector <int> parent(n + 1, 0);
    vector <bool> viz(n + 1);

    int x, y, f;
    for(; m; m--)
    {
        fin>>x>>y>>f;

        path[x].push_back(y);
        path[y].push_back(x);
        flux[x][y] = f;
    }

    int max_flux = 0;

    while(BFS(1, n, path, flux, parent, viz))
    {
        Update(1, n, max_flux, path, flux, parent, viz);
    }

    fout<<max_flux<<'\n';

    return 0;
}