#include <bits/stdc++.h>
using namespace std;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
const int NMAX = 1001, INF = INT_MAX;

struct MaxFlow
{
    struct edge { int u, v, cap; };
    vector<edge> edges;
    vector<int> adj[NMAX];
    int level[NMAX], next_edge[NMAX];

    void add_edge(int u, int v, int cap)
    {
        adj[u].push_back(edges.size());
        edges.push_back({u, v, cap});
        adj[v].push_back(edges.size());
        edges.push_back({v, u, 0});
    }

    bool bfs(int sursa, int dest)
    {
        fill(level, level + NMAX, -1);
        level[sursa] = 0;
        queue<int> q;
        q.push(sursa);
        while(!q.empty())
        {
            int node = q.front();
            q.pop();
            for(int id : adj[node])
            {
                int next = edges[id].v;
                if(edges[id].cap != 0 && level[next] == -1)
                {
                    level[next] = level[node] + 1;
                    q.push(next);
                }
            }
        }
        return (level[dest] != -1);
    }

    int dfs(int u, int dest, int pushed)
    {
        if(u == dest || pushed == 0)
            return pushed;
        for(int &idx = next_edge[u]; idx < adj[u].size(); idx++)
        {
            int id = adj[u][idx], v = edges[id].v;
            if(level[v] == level[u] + 1 && edges[id].cap != 0)
            {
                int impins = dfs(v, dest, min(pushed, edges[id].cap));
                if(impins > 0)
                {
                    edges[id].cap -= impins;
                    edges[id ^ 1].cap += impins;
                    return impins;
                }
            }
        }
        return 0;
    }

    int dinic(int sursa, int dest)
    {
        int flow = 0;
        while(bfs(sursa, dest))
        {
            memset(next_edge, 0, sizeof(next_edge));
            while(int pushed = dfs(sursa, dest, INF))
                flow += pushed;
        }
        return flow;
    }
};
MaxFlow max_flow;

int main()
{
    int n, m;
    fin >> n >> m;
    while(m--)
    {
        int u, v, cap;
        fin >> u >> v >> cap;
        max_flow.add_edge(u, v, cap);
    }
    fout << max_flow.dinic(1, n);

    fin.close();
    fout.close();
    return 0;
}