#include <iostream>
#include <fstream>
#include <climits>
#include <vector>
#include <queue>

using namespace std;

int n, m;
vector<vector<int>> capacitate, la;
vector<int> tata;

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

bool bfs()
{
    vector<bool> viz(n + 1);
    queue<int> q;
    q.push(1);
    viz[1] = true;
    tata[1] = -1;
    while (!q.empty())
    {
        int p = q.front();
        q.pop();
        for (auto adiacent : la[p])
            if (viz[adiacent] == false && capacitate[p][adiacent] != 0)
            {
                tata[adiacent] = p;
                if (adiacent == n)
                    return true;
                viz[adiacent] = true;
                q.push(adiacent);
            }
    }
    return false;
}

int EdmondsKarp()
{
    long maxFlow = 0;
    while (bfs())
    {
        int u, v, pathFlow = INT_MAX;
        for (v = n; v != 1; v = tata[v])
        {
            u = tata[v];
            if (capacitate[u][v] < pathFlow)
                pathFlow = capacitate[u][v];
        }
        for (v = n; v != 1; v = tata[v])
        {
            u = tata[v];
            capacitate[u][v] -= pathFlow;
            capacitate[v][u] += pathFlow;
        }

        maxFlow += pathFlow;
    }
    return maxFlow;
}

int main()
{
    fin >> n >> m;
    la.resize(n + 1);
    tata.resize(n + 1);
    capacitate.resize(n + 1, vector<int>(n + 1));
    for (int i = 1; i <= m; i++)
    {
        //citim datele si punem in lista de adiacenta si in graful rezidual
        //x, y si z, cu semnificatia ca exista o muchie care porneste de la nodul x, ajunge in nodul y si are capacitatea z
        int x, y, z;
        fin >> x >> y >> z;

        fin >> x >> y >> z;
        la[x].push_back(y);
        la[y].push_back(x);
        capacitate[x][y] = z;
    }

    fin.close();
    fout << EdmondsKarp();
    fout.close();
    return 0;
}