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

using namespace std;

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

int x, y, z, solution, N, M;
int C[1024][1024], F[1024][1024], t[1024];
bitset<1024>v;
vector<int>L[1024];
queue<int>Q;

bool BFS()
{
    v.reset();

    Q.push(1);

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

        for(int i = 0; i < L[nod].size(); i ++)
        {
            if(v[ L[nod][i] ] == 0 && C[nod][ L[nod][i] ] > F[nod][ L[nod][i] ])
            {
                Q.push(L[nod][i]);
                v[ L[nod][i] ] = 1;
                t[ L[nod][i] ] = nod;
            }
        }
    }
    if(v[N] == 1)
    {
        return true;
    }

    return false;
}

int main()
{
    fin >> N >> M;

    for(int i = 1; i <= M; i ++)
    {
        fin >> x >> y >> z;
        L[x].push_back(y);
        L[y].push_back(x);
        C[x][y] = z;
    }

    while(BFS())
    {
        int Fmin = (1 << 30);

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

            if(C[x][N] > F[x][N] && v[x] == 1)
            {
                Fmin = C[x][N] - F[x][N];

                while(x > 1)
                {
                    Fmin = min(Fmin, C[ t[x] ][x] - F[ t[x] ][x]);
                    x = t[x];
                }

                x = L[N][i];

                F[x][N] += Fmin;
                F[N][x] -= Fmin;

                while(x > 1)
                {
                    F[ t[x] ][x] += Fmin;
                    F[x][ t[x] ] -= Fmin;
                    x = t[x];
                }

                solution += Fmin;
            }
        }
    }

    fout << solution;

    return 0;
}