# include <cstdio>
# include <vector>

using namespace std;

# define FIN "maxflow.in"
# define FOUT "maxflow.out"
# define min(A, B) (A < B ? A : B)
# define max 1100000
# define PB push_back
# define MAX_N 1005

int N, M;
int Q[MAX_N];
int T[MAX_N];
int viz[MAX_N];
int F[MAX_N][MAX_N];
int C[MAX_N][MAX_N];
vector <int> G[MAX_N];

    int BFS()
    {
        int ct, i;
        vector <int> :: iterator it;
        
        ct = 1;
        Q[1] = 1;
        memset(viz, 0, sizeof(viz));
        viz[1] = 1;
        
        for (i = 1; i <= ct; ++i)
           for (it = G[Q[i]].begin(); it < G[Q[i]].end(); ++it)
              if (!viz[*it] && C[Q[i]][*it]!=F[Q[i]][*it])
              {
                  viz[*it] = 1;
                  if (*it == N) continue;
                  Q[++ct] = *it;
                  T[*it] = Q[i];
              }
        
        return viz[N];
    }

    void maxflow()
    {
        int fmax = 0, flux, i;
        vector <int> :: iterator it;
        
        while (BFS())
        {
            for (it = G[N].begin(); it < G[N].end(); ++it)
               {
                   T[N] = *it;
                   
                   if (!viz[*it] || C[*it][N] == F[*it][N])
                      continue;
                   
                   flux = max;
                   for (i = N; i != 1; i = T[i])
                      flux = min(flux, C[T[i]][i] - F[T[i]][i]);
                   
                   for (i = N; i != 1; i = T[i])
                   {
                       F[T[i]][i] += flux;
                       F[i][T[i]] -= flux;
                   }
                   
                   fmax += flux;
               }
        }
           
        printf("%d",fmax);
    }

    int main()
    {
        freopen(FIN,"r",stdin);
        freopen(FOUT,"w",stdout);
        
        scanf("%d%d",&N,&M);
        
        int a, b, c;
        for (int i = 1; i <= M; ++i)
        {
            scanf("%d%d%d",&a,&b,&c);
            
            C[a][b] += c;
            
            G[a].PB(b);
            G[b].PB(a);
        }
        
        maxflow();
        
        return 0;
    }