#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define debug(x) cerr << #x << " " << x << "\n"
#define debug_with_space(x) cerr << #x << " " << x << " "

using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef pair <ll, ll> pii;
typedef pair <ll, pii> piii;
typedef tree <pii, null_type, less <pii>, rb_tree_tag, tree_order_statistics_node_update> OST;

const ll NMAX = 1001;
const ll INF = (1 << 16) - 1;
const ll MOD = 1000000007;
const ll BLOCK = 101;
const ll nr_of_bits = 20;

vector <int> v[NMAX];
int cap[NMAX][NMAX];
int f[NMAX][NMAX];
int n;
int pre[NMAX];
int tata[NMAX];

int bfs() {
    for(int i = 1; i <= n; i++) {
        pre[i] = -1;
    }
    queue <int> q;
    q.push(1);
    pre[1] = 0;
    while(!q.empty()) {
        int nod = q.front();
        q.pop();
        for(auto x : v[nod]) {
            if(pre[x] == -1 && cap[nod][x] != f[nod][x]) {
                pre[x] = nod;
                if(x == n)
                    return 1;
                q.push(x);
            }
        }
    }
    return 0;
}

int main() {
    ifstream cin("maxflow.in");
    ofstream cout("maxflow.out");
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int m, i;
    cin >> n >> m;
    for(i = 1; i <= m; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        cap[a][b] = c;
        v[a].push_back(b);
        v[b].push_back(a);
    }
    int sum = 0;
    while(bfs()) {
        for(auto x : v[n]) {
            if(pre[x] == -1)
                continue;
            int node = x;
            int minim = cap[x][n] - f[x][n];
            while(pre[node] > 0) {
                minim = min(minim, cap[pre[node]][node] - f[pre[node]][node]);
                node = pre[node];
            }
            node = x;
            f[x][n] += minim;
            f[n][x] -= minim;
            while(pre[node] > 0) {
                f[pre[node]][node] += minim;
                f[node][pre[node]] -= minim;
                node = pre[node];
            }
            sum += minim;
        }

    }
    cout << sum;
    return 0;
}