#include <iostream>

 #include <cstring>

 #include <vector>

 #include <cstdio>

 #include <queue>

 const int N =  +  , M =  +  ;

 using namespace std ;

 int  n , m  ;

 int tot , head[N] ;

 long long ans;

 struct id

 {

     int to , nxt ;

     long  long val ;

 } edge[M<<] ;

 queue< int > Q;

 int dis[N] ,cur[N]; 

 inline void  Init( )

 {

     freopen( "NSOOJ10477.in" , "r" , stdin ) ;

     freopen( "NSOOJ10477.out" , "w" , stdout ) ;

 }

 int read(  )

 {

     char ch = getchar(  ) ; int k =  , ret =  ;

     while( ch > '' || ch < '' ) { if( ch == '-' ) k = - ; ch = getchar( ) ; }

     while( ch <= '' && ch >= '' ) ret = ret *  + ch - '' , ch = getchar( ) ;

     return ret * k ;

 }

 void add( int u , int v , int c )

 {

     edge[++tot].to = v , edge[tot].nxt = head[u] ;

     edge[tot].val = c , head[u] = tot ;

 }

 void input(  )

 {

     n = read( ) , m = read( ) ;

     memset( head , - , sizeof( head ) ) ;

     tot =  ;

     for( int x =  ; x <= m ; ++x  )

     {

         int a, b , c ;

         a = read( ) , b = read( ) , c = read( ) ;

         add( a, b , c ) ;

         add( b , a ,  ) ;

     }

 }

 bool bfs(  )

 {

     memset( dis , - , sizeof(dis) ) ;

     Q.push(  ) ; dis[] =  ;

     while( !Q.empty( ) )

     {

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

         for( int i = head[u] ; ~i ; i = edge[i].nxt )

         {

             int v = edge[i].to ;

             if( dis[v] <  && edge[i].val >  )

             {

                 dis[v] = dis[u] +  ; Q.push( v ) ;

             }

         }

     }

 //    cout<<endl;

     if( dis[n] >  ) return true ;

     return false ;

 }

 long long int dfs( int u , int inf )

 {

     long long int ans = 0ll , cost = 0ll;

     if( u == n ) return inf ;

     for( int i = cur[u] ; ~i ; i = edge[i].nxt )

     {

         int  v = edge[i].to ;

         if( dis[v] != dis[u] +  ) continue ;

         ans = dfs( v , min( inf - cost , edge[i].val ) ) ;

         edge[i].val -= ans ;

         edge[i^].val += ans ;

         if( edge[i].val ) cur[u] = i ;

         cost += ans ;

         if( cost == inf ) return inf ;

     }

     if( !cost ) dis[u] = - ;

     return  cost ;

 }

 void sov(  )

 {

     ans =  ;

     while( bfs( ) )

     {

         int now ;

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

         ans += dfs(  , << ) ;

     }

     printf( "%lld" , ans ) ;

 }

 int main(  )

 {

 //    Init( ) ;

     input(  ) ;

     sov( ) ;

 //    fclose( stdin ) ;

 //    fclose( stdout ) ;

     return  ;

 }

 #include <iostream>

 #include <cstring>

 #include <cstdio>

 #include <queue>

 const int N = , M = 3e5 + , inf =  << ;

 using namespace std;

 int n, m, head[N], cnt, dis[N],cur[N];

 queue<int>Q;

 struct edge

 {

     int nxt,to,vi;

 } E[M<<];

 void add(int u,int v,int vi)

 {

     E[++cnt] = (edge){head[u],v,vi}; head[u] = cnt;

     E[++cnt] = (edge){head[v],u,}; head[v] = cnt;

 }

 void Init()

 {

     scanf("%d%d",&n,&m); cnt = -;

     int u,v,vi;

     memset(head,-,sizeof(head));

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

     {

         scanf("%d%d%d",&u,&v,&vi);

         add(u,v,vi);

     }

 }

 bool bfs()

 {

     memset(dis,-,sizeof(dis));

     Q.push(); dis[] = ;

     while(!Q.empty())

     {

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

         for(int i = head[u]; ~i; i = E[i].nxt)

         {

             int v = E[i].to;

             if(dis[v] == - && E[i].vi > ) dis[v] = dis[u] + , Q.push(v);

         }

     }

     return (dis[n] > );

 }

 int dfs(int u,int t,int ff)

 {

     int ret = , cost = ;

     if(u == t) return ff;

     for(int i = cur[u] ; ~i; i = E[i].nxt)

     {

         int v = E[i].to;

         if(dis[v] != dis[u] + ) continue;

         cost = dfs(v,t,min(ff-ret,E[i].vi));

         E[i].vi -= cost, E[i^].vi += cost; ret += cost;

         if(E[i].vi) cur[u] = i;

         if(ret == ff) return ff;

     }

     if(!ret) dis[u] = -;

     return ret;

 }

 int max_flow(int s,int t)

 {

     int ret = ;

     while(bfs())

     {

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

         ret += dfs(s,t,inf);

     }

     return ret;

 }

 void Solve()

 {

     int ans = max_flow(,n);

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

 }

 int main()

 {

     Init();

     Solve();

     return ;

 }