kotli

/**
 * User: qwerty787788
 * Date: 06.12.13
 * Time: 20:56
 */



import java.io.InputStreamReader
import java.io.BufferedReader
import java.util.StringTokenizer
import java.util.ArrayList


fun isPrime(x: Int): Boolean {
    if (x == 1)
        return false;
    var j = 2
    while (j * j <= x) {
        if (x % j == 0)
            return false;
        j++;
    }
    return true;
}

var br = BufferedReader(InputStreamReader(System.`in`))
var st = StringTokenizer("") : StringTokenizer;

fun next() : String {
    while (!st.hasMoreElements()) {
        var s = br.readLine();
        st = StringTokenizer(s);
    }
    return st.nextToken();
}

fun nextInt(): Int {
    return Integer.parseInt(next());
}

fun sol() {
    var max = nextInt()
    var sum = 0;
    for (i in 2..max)
        if (isPrime(i))
            sum += i;
    println(sum);
    if (isPrime(sum)) {
        println("YES");
    } else {
        println("NO");
    }
}

fun solA() {
    println(nextInt() + nextInt());
}

fun solB() {
    var s = next();
    var sum1 = 0;
    var sum2 = 0;
    for (i in 0..2) {
        sum1 += s.charAt(i)-'0';
    }
    for (i in 3..5) {
        sum2 += s.charAt(i)-'0';
    }
    if (sum1 == sum2) {
        println("Lucky ticket");
    } else {
        println("Unlucky ticket");
    }
}

fun solC() {
    var t = nextInt();
    var res = 0;
    for (i in 2..t/2)
        if (isPrime(i) && isPrime(t - i))
            res++;
    println(res);
}

fun solD() {
    var n = nextInt();
    var m = nextInt();
    var d =Array(n) {IntArray(n)};
    for (i in 0..n-1)
        for (j in 0..n-1)                   {
            d[i][j] =  Integer.MAX_VALUE / 3;
            if (i == j)
                d[i][j] = 0;
        }
    for (i in 1..m) {
        var fr = nextInt() - 1;
        var to = nextInt() - 1;
        var cost = nextInt();
        if (d[fr][to] > cost)
            d[fr][to] = cost;
    }
    for (i in 0..n-1)
        for (j in 0..n-1)
            for (k in 0..n-1)
                if (d[j][i]+d[i][k] < d[j][k])
                    d[j][k] = d[j][i] + d[i][k];
    for (i in 0..n-1) {
        for (j in 0..n - 1) {
            print(d[i][j]);
            print(" ");
        }
        println();
    }
}

fun solE() {
    var n = nextInt();
    var a = IntArray(n);
    for (i in 0..n-1)
        a[i] = nextInt();
    var m = nextInt();
    var b = IntArray(m);
    for (i in 0..m- 1)
        b[i] = nextInt();
    var dp = Array(n+1) {IntArray(m+1)};
    for (i in 0..n-1)
        for (j in 0..m-1) {
            if (a[i] == b[j]) {
                dp[i+1][j+1] = 1 + dp[i][j];
            }
            if (dp[i][j+1] > dp[i + 1][j + 1])
                dp[i+1][j+1]=dp[i][j+1];
            if (dp[i+1][j] > dp[i + 1][j + 1])
                dp[i+1][j+1] = dp[i + 1][j];
        }
    var ans = arrayListOf<Int>();
    var i = n;
    var j = m;
    while (i != 0 && j != 0) {
        if (a[i - 1] == b[j - 1]) {
            ans.add(a[i - 1]);
            i--; j--;
        } else {
            if (dp[i-1][j] == dp[i][j]) {
                i--;
            } else {
                j--;
            }
        }
    }
    println(ans.size());
    for (i in 0..ans.size()-1) {
        print(ans.get(ans.size() - 1 - i));
        print(" ");
    }
}


private class Road(fr1 : Int, to1 : Int, cap1 : Long) {
    var fr = fr1;
    var to = to1;
    var cap = cap1;
    var used = 0 : Long;
    var rev = this : Road;
}

fun bfs(g : Array<ArrayList<Road>>, h : Array<Int>) : Boolean {
    var n = g.size;
    var was = arrayListOf<Int>();
    var wasArray = BooleanArray(n);
    was.add(0);
    h[0] = 0;
    wasArray[0] = true;
    var it = 0;
    while (it < was.size) {
        var v = was.get(it);
        it++;
        for (r in g[v]) {
            if (r.used < r.cap && !wasArray[r.to]) {
                wasArray[r.to] = true;
                was.add(r.to);
                h[r.to] = h[r.fr] + 1;
            }
        }
    }
    return wasArray[n-1];
}

fun dfs(v : Int, flow : Long, h : Array<Int>, g : Array<ArrayList<Road>>, start : Array<Int>) : Long {
    var n = g.size;
    if (v == n - 1 || flow == 0.toLong())
        return flow;
    while (start[v] < g[v].size()) {
        var r = g[v][start[v]];
        start[v]++;
        if (r.used < r.cap && h[r.to] == h[r.fr] + 1) {
            var more = dfs(r.to, Math.min(flow, r.cap - r.used), h, g, start);
            if (more != 0.toLong()) {
                r.used += more;
                r.rev.used -= more;
                return more;
            }
        }
    }
    return 0.toLong();
}

fun solF() {
    var n = nextInt();
    var m = nextInt();

   var g = Array(n){arrayListOf<Road>()}
    for (i in 0..m - 1) {
        var fr = nextInt() - 1;
        var to = nextInt() - 1;
        var cap = nextInt().toLong();
       var r = Road(fr, to, cap);
        var r2 = Road(to, fr, 0.toLong());
        r.rev = r2;
        r2.rev = r;
        g[fr].add(r);
        g[to].add(r2);
    }
    var res = 0.toLong();
    var h = Array(n){-1};
    var inf = (1e18).toLong();
    while (bfs(g, h)) {
        var startFrom = Array(n){0};
        while (true) {
            var more = dfs(0, inf, h, g, startFrom);
            if (more == 0.toLong())
                break;
            res += more;
        }
    }
    println(res);
}

fun main(args: Array<String>): Unit {
    solF();
}