#include <fstream>
#include <vector>
#include <queue>
#include <string.h>
using namespace std;

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

const int N_MAX = 1000;
const int M_MAX = 5000;
const int INF = 0x7fffffff;
int N;
int min(int a, int b)
{
    return (a<b)?a:b;
}

bool vizitat[N_MAX+1];
int C[N_MAX+1][N_MAX+1];
int F[N_MAX+1][N_MAX+1];
int tata[N_MAX+1];
vector<int> vecini[N_MAX+1];

int BFS()
{
    memset(vizitat, 0, N+1);
    queue<int> frontiera;
    frontiera.push(1);
    vizitat[1] = true;
    while(!frontiera.empty())
    {
        int nod = frontiera.front();
        frontiera.pop();
        if(nod == N) continue;
        for(int m : vecini[nod])
        {
            if(C[nod][m] == F[nod][m] | vizitat[m]) continue;
            tata[m] = nod;
            frontiera.push(m);
            vizitat[m] = true;
        }
    }
    return vizitat[N];
}

int main()
{
    int M;
    in >> N >> M;
    for(int i = 0; i < M; i++)
    {
        int x, y, z;
        in >> x >> y >> z;
        vecini[x].push_back(y);
        vecini[y].push_back(x);
        C[x][y] = z;
    }
    int flux = 0;
    while(BFS())
    {
        for(int m : vecini[N])
        {
            if(C[m][N] == F[m][N] | !vizitat[m]) continue;
            tata[N] = m;
            int fmin = INF;
            for(int nod = N; nod!=1; nod = tata[nod])
                fmin = min(fmin, C[ tata[nod] ][nod] - F[ tata[nod] ][nod] );
            if(fmin == 0) continue;
            for(int nod = N; nod!=1; nod = tata[nod])
            {
                F[ tata[nod] ][nod] += fmin;
                F[nod][ tata[nod] ] -= fmin;
            }
            flux += fmin;
        }
    }


    out << flux;
    return 0;
}