#include <bits/stdc++.h>
#define pb push_back

using namespace std;

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

void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << H; debug_out(T...);}
#define dbg(...) cerr << #__VA_ARGS__ << " ->", debug_out(__VA_ARGS__)
#define dbg_v(x, n) do{cerr<<#x"[]: ";for(int _=0;_<n;++_)cerr<<x[_]<<" ";cerr<<'\n';}while(0)
#define dbg_ok cerr<<"OK!\n"

typedef pair<int,int> pii;
typedef long long int ll;
typedef long double ld;

const int DMAX = 1e5+10;

struct Edge {
  int to, flow, cap, rev;
};

class maxFlow {
    private:
        int n;
        vector<vector<Edge>> g;
        vector<int> dist, rem;
        int s, d;
    public:
        maxFlow(int n, int s, int d) {
            this->n = n;
            this->s = s;
            this->d = d;
            g.resize(1 + n);
            dist.resize(1 + n);
            rem.resize(1 + n);
        }
        void addEdge(int from, int to, int cap) {
            g[from].push_back({to, 0, cap, g[to].size()});
            g[to].push_back({from, 0, 0, g[from].size() - 1});
        }
        bool bfs(){
            for(int i = 1;i <= n; i++)
            dist[i] = 1e9;
            queue<int> q;
            q.push(s);
            dist[s] = 0;
            while(!q.empty()){
                int node = q.front();
                q.pop();
                for(auto& e:g[node]){
                    if(dist[node] + 1 < dist[e.to] && e.flow < e.cap){
                        dist[e.to] = dist[node] + 1;
                        q.push(e.to);
                    }
                }
            }
            return 1e9 != dist[d];
        }
        int dfs(int node, int deltaflow){
            if(node == d)
                return deltaflow;
            else{
                for(int &h = rem[node]; h < g[node].size(); h++){
                    Edge &e = g[node][h];
                    if(dist[node] + 1 == dist[e.to] && e.flow < e.cap){
                        int flow = dfs(e.to, min(deltaflow, e.cap - e.flow));
                        if(0 < flow){
                            e.flow += flow;
                            g[e.to][e.rev].flow -= flow;
                            return flow;
                        }
                    }
                }
                return 0;
            }
        }
        int maxflow(){
            int result = 0;
            while(bfs()){
                for(int i = 1;i <= n; i++)
                    rem[i] = 0;
                int deltaflow = dfs(s, 1e9);
                while(0 < deltaflow){
                    result += deltaflow;
                    deltaflow = dfs(s, 1e9);
                }
            }
            return result;
        }
};

int V[DMAX];

int n,m;

int main(){
    int t,i,j;
    int x,y,z;

    fin>>n>>m;
    maxFlow flux(n,1,n);
    while(m--){
        fin>>x>>y>>z;
        flux.addEdge(x,y,z);
    }
    fout<<flux.maxflow()<<'\n';
    return 0;
}