#include <fstream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cstring>

using namespace std;

typedef vector<int>::iterator vii;

const int MaxN = 1005;
const int oo = 1000000000;

struct Edge {
    int V, Capacity, Flow;
};

vector<int> G[MaxN];
vector<Edge> E;
int N, M, S, D, Father[MaxN], MaxFlow;
queue<int> Q;

inline int NonE(int e) {
    return e < M ? e+M : e-M;
}

inline void InitBFS(int Start) {
    memset(Father, -1, sizeof(Father));
    Q.push(Start), Father[Start] = 0;
}

bool BFS(int Start, int End) {
    for (InitBFS(Start); !Q.empty(); Q.pop()) {
        int X = Q.front();
        if (X == End)
            continue;
        for (vii e = G[X].begin(); e != G[X].end(); ++e)
            if (Father[E[*e].V] == -1 && E[*e].Capacity > E[*e].Flow)
                Q.push(E[*e].V), Father[E[*e].V] = NonE(*e);
    }
    return Father[End] != -1;
}

void EdmondsKarp() {
    while (BFS(S, D)) {
        for (vii e = G[D].begin(); e != G[D].end(); ++e) {
            if (Father[E[*e].V] == -1 || E[NonE(*e)].Capacity <= E[NonE(*e)].Flow)
                continue;
            int Flow = oo;
            for (int X = D; X != S; X = E[Father[X]].V)
                Flow = min(Flow, E[NonE(Father[X])].Capacity-E[NonE(Father[X])].Flow);
            for (int X = D; X != S; X = E[Father[X]].V)
                E[NonE(Father[X])].Flow += Flow, E[Father[X]].Flow -= Flow;
            MaxFlow += Flow;
        }
    }
}

void Read() {
    ifstream fin("maxflow.in");
    fin >> N >> M; E.resize(2*M);
    for (int i = 0; i < M; ++i) {
        int X, Y, C; fin >> X >> Y >> C;
        G[X].push_back(i), G[Y].push_back(i+M);
        E[i].V = Y, E[i].Capacity = C, E[i].Flow = 0;
        E[NonE(i)].V = X, E[NonE(i)].Capacity = 0, E[NonE(i)].Flow = 0;
    }
    S = 1, D = N;
    fin.close();
}

void Print() {
    ofstream fout("maxflow.out");
    fout << MaxFlow << "\n";
    fout.close();
}

int main() {
    Read();
    EdmondsKarp();
    Print();
    return 0;
}