#include <cstdio>

 #include <iostream>

 #include <algorithm>

 #include <cstring>

 #include <cmath>

 #include <queue>

 using namespace std;

 typedef long long L;

 const int maxn =  + ;

 const int maxm =  + ;

 const int INF = -1u >> ;

 int fch[maxn], n, m;

 L ans = ;

 bool vis[maxn];

 struct Tedge{

     int from, to, cap, flow, next;

 }adj[maxm];

 struct Dinic{

     int S, T, n, ms;

     int d[maxn], cur[maxn], fch[maxn];

     void init(int n){

         this -> n = n;

         memset(fch, -, sizeof(fch));

         ms = ;

         return ;

     }

     void AddEdge(int u, int v, int c){

         adj[ms] = (Tedge){u, v, c, , fch[u]};

         fch[u] = ms ++;

         adj[ms] = (Tedge){v, u, , , fch[v]};

         fch[v] = ms ++;

         return ;

     }

     bool BFS(){

         memset(vis, , sizeof(vis));

         queue<int> Q;

         Q.push(S); vis[S] = true; d[S] = ;

         while(!Q.empty()){

             int x = Q.front(); Q.pop();

             for(int i = fch[x]; i != -; i = adj[i].next){

                 Tedge& e = adj[i];

                 if(!vis[e.to] && e.cap > e.flow){

                     vis[e.to] = true;

                     d[e.to] = d[x] + ;

                     Q.push(e.to);

                 }

             }

         }

         return vis[T];

     }

     int DFS(int x, int a){

         if(x == T || !a) return a;

         int flow = , f;

         for(int& i = cur[x]; i != -; i = adj[i].next){

             Tedge& e = adj[i];

             if(d[e.to] == d[x] +  && (f = DFS(e.to, min(a, e.cap - e.flow))) > ){

                 flow += f;

                 a -= f;

                 e.flow += f;

                 adj[i ^ ].flow -= f;

                 if(!a) break;

             }

         }

         return flow;

     }

     L Max_Flow(int S, int T){

         this -> S = S;

         this -> T = T;

         L flow = ;

         while(BFS()){

             for(int i = ; i < n; i ++) cur[i] = fch[i];

             flow += DFS(S, INF);

         }

         return flow;

     }

 }sol;

 void read(int &x){

     x = ; int sig = ; char ch = getchar();

     while(!isdigit(ch)) { if(ch == '-') sig = -; ch = getchar(); }

     while(isdigit(ch)) x =  * x + ch - '', ch = getchar();

     x *= sig; return ;

 }

 void init(){

     read(n); read(m);

     sol.init(n);

     int u, v, w;

     for(int i = ; i < m; i++){

         read(u); read(v); read(w);

         sol.AddEdge(u, v, w);

     }

     return ;

 }

 void work(){

     ans = sol.Max_Flow(, n);

     return ;

 }

 void print(){

     printf("%lld\n", ans);

     return ;

 }

 int main(){

     init();

     work();

     print();

     return ;

 }