#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#include <climits>

using namespace std;

int BFS (int start, int finish);
void EdmondsKarp (int start, int finish);

int N, M;
int x, y, z;
int capacity[1001][1001];

vector <int> G[1001];
queue <int> Q;
int flow[1001][1001];
int parent[1001];
bool seen[1001];
int i;

int F;

int main ()
{
    ifstream fin ("maxflow.in");
    fin >> N >> M;
    for (i=1; i<=M; i++)
    {
        fin >> x >> y >> z;
        G[x].push_back(y);
        G[y].push_back(x);
        capacity[x][y] = z;
    }
    fin.close();
    EdmondsKarp(1,N);
    ofstream fout ("maxflow.out");
    fout << F;
    fout.close();
    return 0;
}

int BFS (int start, int finish)
{
    int node;
    int i;
    memset(seen,0,sizeof(seen));
    Q.push(start);
    seen[start] = 1;
    while (!Q.empty())
    {
        node = Q.front();
        Q.pop();
        for (i=0; i<G[node].size(); i++)
            if (!seen[G[node][i]] && capacity[node][G[node][i]] > flow[node][G[node][i]])
            {
                seen[G[node][i]] = 1;
                parent[G[node][i]] = node;
                if (finish != G[node][i])
                    Q.push(G[node][i]);
            }
    }
    return seen[finish];
}

void EdmondsKarp (int start, int finish)
{
    int node;
    int Flow;
    int i;
    while (BFS(start,finish))
        for (i=0; i<G[finish].size(); i++)
            if (seen[G[finish][i]] && capacity[G[finish][i]][finish] > flow[G[finish][i]][finish])
            {
                parent[finish] = G[finish][i];
                Flow = INT_MAX;
                for (node=finish; node!=start; node=parent[node])
                    if ((capacity[parent[node]][node]-flow[parent[node]][node]) < Flow)
                        Flow = capacity[parent[node]][node] - flow[parent[node]][node];
                for (node=finish; node!=start; node=parent[node])
                {
                    flow[parent[node]][node] += Flow;
                    flow[node][parent[node]] -= Flow;
                }
                F += Flow;
            }
}