#include <bits/stdc++.h>
#include <fstream>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template<class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
struct custom_hash {static uint64_t splitmix64(uint64_t x) {x += 0x9e3779b97f4a7c15;x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;x = (x ^ (x >> 27)) * 0x94d049bb133111eb;return x ^ (x >> 31);}size_t operator()(uint64_t x) const {static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();return splitmix64(x + FIXED_RANDOM);}};
string __fname = "maxflow"; ifstream in (__fname + ".in"); ofstream out (__fname + ".out"); 
#define cin in 
#define cout out
#define int64 long long
#define uint64 unsigned long long
#define x first
#define y second
#define pb push_back
#define pii pair <int, int> 
#define pii64 pair <int64, int64>
#define db(x) cout << "> " << #x << ": " << (x) << "\n"
#define qr queries()
#define yn(x) if (x) {ctn("Yes");}else {ctn("No");}
void solve(int);
void queries(){int n;cin >> n;for (int i = 1; i <= n; i++) solve(i);}
template<class T>T ceildiv(T a, T b) {return a / b + !!(a % b);}
template<class T>T gcd (T a, T b){return (b ? gcd(b, a % b): a);}
template<class T>T lcm (T a, T b){return a * b / gcd(a, b);}
// // // // // // // // // // // // // // // // // // // // // // 
/*                  TEMPLATE - VANILLA                         */
// // // // // // // // // // // // // // // // // // // // // //
const int ddx[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int ddy[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const double pi = 3.14159265359;
const double eps = 1e-6;
const int64 hash_inv = 940594066;
const int64 hash_p = 101;
const int64 mod = 1e9 + 7;
const int maxn = 2e5 + 2;

void solve(int id){
    
    return;
}

template <class T> class Dinic {
    public:
    struct edge {
        int v, rev;
        T c;
    };
    int n;
    vector <vector <edge> > ad;
    vector <int> lvl, ptr;
    Dinic(int n) {
        this->n = n;
        ad.resize(n);
    }
    void addEdge (int x, int y, T c) {
        ad[x].push_back({y, (int) ad[y].size(), c});
        ad[y].push_back({x, (int) ad[x].size() - 1, 0});
    }
    bool bfs (int s, int t) {
        lvl = ptr = vector <int> (n, 0);
        lvl[s] = 1;
        queue <int> q;
        q.push(s);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (auto [v, rev, c]: ad[u]) {
                if (!lvl[v] && c) {
                    lvl[v] = lvl[u] + 1;
                    q.push(v);
                    if (v == t) return 1;
                }
            }
        }
        return 0;
    }
    T dfs (int u, int t, T flow) {
        if (u == t) return flow;
        for (int& i = ptr[u]; i < (int) ad[u].size(); i++) {
            auto& [v, rev, c] = ad[u][i];
            if (lvl[v] != lvl[u] + 1 || !c) continue;
            if (T f = dfs(v, t, min(flow, c))) {
                c-=f;
                ad[v][rev].c+=f;
                return f;
            }
        }
        return 0;
    }
    T maxFlow (int s, int t) {
        T rs = 0;
        while (bfs(s, t)) {
            while (T k = dfs(s, t, 1e9)) rs+=k;
        }
        return rs;
    }
};

int main(){
    int n,m;
    cin >> n >> m;
    Dinic <int64> dinic (n + 1);
    for (int i = 0; i < m; i++){
        int x,y,c;
        cin >> x >> y >> c;
        dinic.addEdge(x,y,c);
    }
    // cout << dinic.bfs(1, n) << "\n";
    cout << dinic.maxFlow(1, n) << "\n";
    return 0;
}