#include <fstream>
#include <vector>
#include <bitset>
#include <cstring>

#define DIM 1001

using namespace std;

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

int solution, a, b, c, x, minimum;
int T[DIM], flow[DIM][DIM], capacity[DIM][DIM];
int q[DIM], N, M;

bitset<DIM> v;
vector<int> L[DIM];

int BFS()
{
    for(int i = 1; i <= N; i ++)
    {
        v[i] = 0;
    }

    int p = 1;
    int u = 1;
    q[1] = v[1] = 1;

    while(p <= u)
    {
        for(int i = 0; i < L[ q[p] ].size(); i ++)
        {
            if( v[ L[q[p]][i] ] == 0 && capacity[ q[p] ][ L[q[p]][i] ] > flow[ q[p] ][ L[q[p]][i] ] )
            {
                q[++ u] = L[q[p]][i];
                v[ L[q[p]][i] ] = 1;
                T[ L[q[p]][i] ] = q[p];
            }
        }
        p ++;
    }
    return v[N];
}

int main()
{

    fin >> N >> M;

    for(int i = 0; i <= M; i ++)
    {
        fin >> a >> b >> c;
        L[a].push_back(b);
        L[b].push_back(a);
        capacity[a][b] = c;
    }

    while( BFS() )
    {
        for(int i = 0; i < L[N].size(); i ++)
        {
            x = L[N][i];

            if(capacity[x][N] > flow[x][N] && v[x])
            {
                minimum = capacity[x][N] - flow[x][N];

                while(x != 1)
                {
                    if( capacity[ T[x] ][x] - flow[ T[x] ][x] < minimum)
                    {
                        minimum = capacity[ T[x] ][x] - flow[ T[x] ][x];
                    }

                    x = T[x];
                }

                x = L[N][i];

                flow[x][N] += minimum;
                flow[N][x] -= minimum;

                while( x != 1)
                {
                    flow[ T[x] ][x] += minimum;
                    flow[x][ T[x] ] -= minimum;
                    x = T[x];
                }

                solution += minimum;
            }
        }
    }

    fout << solution;

    return 0;
}