#include <bits/stdc++.h>
#define NMAX 1008
#define INF 1e9

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

struct Muchie
{
    int vf, f, c, rev;
};

int n, m;
int level[NMAX];
vector <Muchie> G[NMAX];

void citire();
void rezolvare();
bool BFS();
int sendFlow(int nod, int flow);

int main()
{
    citire();
    rezolvare();
    return 0;
}

void citire()
{
    int x, y, z;
    fin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        fin >> x >> y >> z;
        G[x].push_back({y, 0, z, G[y].size()+1});
        G[y].push_back({x, 0, 0, G[x].size()});
    }
}

void rezolvare()
{
    int max_flow = 0;

    while (BFS())
    {
        while (1)
        {
            int flow = sendFlow(1, INF);
            if (flow == 0)
                break;
            max_flow += flow;
        }
    }

    fout << max_flow;
}

bool BFS()
{
    for (int i = 1; i <= n; i++)
        level[i] = -1;
    level[1] = 0;
    queue <int> Q;
    Q.push(1);

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

        for (int i = 0; i < G[nod].size(); i++)
        {
            int vf = G[nod][i].vf;
            int f = G[nod][i].f;
            int c = G[nod][i].c;
            if (f < c && level[vf] == -1)
            {
                level[vf] = level[nod] + 1;
                Q.push(vf);
            }
        }
    }

    if (level[n] == -1)
        return 0;
    return 1;
}

int sendFlow(int nod, int flow)
{
    if (nod == n)
        return flow;

    for (int i = 0; i < G[nod].size(); i++)
    {
        int vf = G[nod][i].vf;
        if (level[vf] == level[nod] + 1)
        {
            int crt = min(flow, G[nod][i].c - G[nod][i].f);
            int temp = sendFlow(vf, crt);

            if (temp > 0)
            {
                G[nod][i].f += temp;
                int i2 = G[nod][i].rev;
                G[vf][i2].f -= temp;
                return temp;
            }
        }
    }

    return 0;
}