#include <bits/stdc++.h>
#define N_MAX 1000 + 1
using namespace std;


vector<vector<int>> graph(N_MAX, vector<int>());
int N, M;

int C[N_MAX][N_MAX], F[N_MAX][N_MAX], TT[N_MAX];
bool VIZ[N_MAX];


bool BFS(){

    fill(VIZ + 1, VIZ + N + 1, false);

    queue<int> q;

    q.push(1);
    VIZ[1] = true;

    while(!q.empty())
    {
        int node = q.front();

        q.pop();

        if(node == N) continue;

        for(auto& next: graph[node])
        {
            if(VIZ[next] == true || C[node][next] == F[node][next]) continue;

            VIZ[next] = true;
            TT[next] = node;
            q.push(next);
        }
    }

    return VIZ[N];
}

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

    fin >> N >> M;

    for(int i = 1; i <= M; ++i)
    {
        int x, y, c;
        fin >> x >> y >> c;

        C[x][y] = c;

        graph[x].push_back(y);
        graph[y].push_back(x);
    }


    int maxflow = 0;

    while(BFS())
    {
        for(auto& nb : graph[N])
        {
            if(VIZ[nb] == false || C[nb][N] == F[nb][N]) continue;

            TT[N] = nb;

            int flow = (1 << 30);

            for(int i = N; i != 1; i = TT[i])
                flow = min(flow, C[TT[i]][i] - F[TT[i]][i]);

            if(flow == 0) continue;

            for(int i = N; i != 1; i = TT[i])
            {
                F[TT[i]][i] += flow;
                F[i][TT[i]] -= flow;
            }

            maxflow += flow;
        }
    }

    fout << maxflow;
}