// Author: Tanasescu Andrei-Rares
/*
     █████╗  ██████╗ ████████╗
    ██╔══██╗ ██╔══██╗╚══██╔══╝
    ███████║ ██████╔╝   ██║   
    ██╔══██║ ██╔══██╗   ██║   
    ██║  ██║ ██║  ██║   ██║   
    ╚═╝  ╚═╝ ╚═╝  ╚═╝   ╚═╝   
*/
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <queue>
#include <stack>
#include <deque>
#include <iomanip>
#include <vector>
#include <cassert>

#pragma GCC optimize("O3")

#define fi first
#define se second
#define pb push_back
#define pf push_front

using namespace std;

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

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const ll Nmax=1e3+5, Mmax=5e3+5, inf=1e9+5;

int n, m;
ll flow;

struct edge{
    int a, b;
    int c, f;
}e[2*Mmax];
vector<int> ad[Nmax];

int dist[Nmax];
bool blocked[Nmax];

queue<int> q;
inline bool bfs(){
    for (int i=1; i<=n; i++)
        dist[i]=blocked[i]=0;
    
    dist[1]=1;
    q.push(1);
    while (!q.empty()){
        int node=q.front();
        q.pop();

        for (auto it:ad[node]){
            int nxt=e[it].b;
            if (e[it].c!=e[it].f && dist[nxt]==0){
                dist[nxt]=dist[node]+1;
                q.push(nxt);
            }
        }
    }

    return dist[n];
}

int dfs(int node, int crtflow){
    if (node==n)
        return crtflow;
    
    blocked[node]=1;

    int pushed=0;
    for (auto it:ad[node]){
        int nxt=e[it].b;
        if (dist[nxt]==dist[node]+1){
            if (e[it].c!=e[it].f && !blocked[nxt]){
                int df=dfs(nxt, min(crtflow, e[it].c-e[it].f));
                pushed+=df;
                crtflow-=df;
                e[it].f+=df;
                e[it^1].f-=df;
            }
            if (e[it].c!=e[it].f && !blocked[nxt])
                blocked[node]=0;
        }
    }

    return pushed;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    fin>>n>>m;
    for (int i=0; i<m; i++){
        int a, b, c;
        fin>>a>>b>>c;
        e[2*i]={a, b, c, 0};
        e[2*i+1]={b, a, 0, 0};

        ad[a].pb(2*i);
        ad[b].pb(2*i+1);
    }
    
    // Dinic
    while (bfs())
        flow+=dfs(1, inf);

    fout<<flow<<'\n';

    /*for (ll i=0; i<m; i++)
        cout<<e[2*i].f<<'\n';*/

    return 0;
}