#include <fstream>
#include <vector>
#include <queue>

using namespace std;

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

const int VAL=1005;
const int INF=1000000000;

int N, M, i, j, A, B, prec[VAL], nod;
int Capacity[VAL][VAL], Flow, mn;
bool viz[VAL];
queue <int> Q;
vector <int> G[VAL];
vector <int> :: iterator it;

bool BFS()
{
    for (i=1; i<=N; i++)
    {
        prec[i]=0;
        viz[i]=false;
    }
    Q.push(1);
    viz[1]=true;
    while (Q.empty()==false)
    {
        nod=Q.front();
        Q.pop();
        if (nod==N)
            continue;
        for (it=G[nod].begin(); it!=G[nod].end(); it++)
        {
            if (viz[*it]==false && Capacity[nod][*it]>0)
            {
                viz[*it]=true;
                prec[*it]=nod;
                Q.push(*it);
            }
        }
    }
    return viz[N];
}

void Ford_Fulkerson()
{
    while (BFS()==true)
    {
        for (j=0; j<G[N].size(); j++)
        {
            prec[N]=G[N][j];
            mn=INF;
            nod=N;
            while (1)
            {
                mn=min(mn, Capacity[prec[nod]][nod]);
                nod=prec[nod];
                if (nod==1)
                    break;
            }
            Flow+=mn;
            nod=N;
            while (1)
            {
                Capacity[prec[nod]][nod]-=mn;
                Capacity[nod][prec[nod]]+=mn;
                nod=prec[nod];
                if (nod==1)
                    break;
            }
        }
    }
}

int main()
{
    fin >> N >> M;
    for (i=1; i<=M; i++)
    {
        fin >> A >> B >> Capacity[A][B];
        G[A].push_back(B);
        G[B].push_back(A);
    }
    Ford_Fulkerson();
    fout << Flow << '\n';
    fin.close();
    fout.close();
    return 0;
}