#include<fstream>
#include<vector>
#include<queue>
#include<bitset>
#include<cstring>
using namespace std;

const int NMAX = 1e3 + 1;

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

vector<int> vecini[NMAX];

int n,cap[NMAX][NMAX],flow[NMAX][NMAX],level[NMAX],t[NMAX];

bitset<NMAX> fost;

bool bfs()
{
    vector<bool> viz(n + 1,false);
    queue<int> q;

    q.push(1);

    while(!q.empty())
        {
            int v = q.front();
            q.pop();

            for(auto it : vecini[v])
                {
                    if(viz[it] || !(cap[v][it] - flow[v][it]))///verific daca este muchie care sa aiba capacitatea reziduala pozitiva
                        continue;


                    level[it] = level[v] + 1;
                    viz[it] = 1;q.push(it);
                }
        }

    return viz[n];
}

int dfs(int nod,int f,int p = 0)
{
    if(nod == n)
        {
            while(nod != 1)
                {
                    flow[t[nod]][nod] += f;
                    flow[nod][t[nod]] -= f;

                    nod = t[nod];
                }

            return f;
        }


    for(auto it : vecini[nod])
        {
            if(it == p || level[it] != level[nod] + 1 || !(cap[nod][it] - flow[nod][it]) || fost[it])
                continue;

            t[it] = nod;
            int best = dfs(it,min(f,cap[nod][it] - flow[nod][it]),nod);
            if(!best) fost[nod] = 1;
            else return best;

        }

    return 0;
}

///TO do : de verificat daca pot gasi mai multe drumuri de augmentare din un singur dfs

void dinic()
{
    long long total = 0;
    int now;
    for(;;)
        {
            memset(level,sizeof(level),0);
            memset(t,sizeof(t),0);
            if(!bfs())
                break;

            fost.reset();
            level[1] = 0;

            while(now = dfs(1,1e9))
                total += now;

        }

    cout << total << endl;
}

int main()
{
    int m,a,b,c; cin >> n >> m;
    while(m--)
        {
            cin >> a >> b >> c;
            vecini[a].emplace_back(b);
            vecini[b].emplace_back(a);
            cap[a][b] = c;
        }



    dinic();
}