#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
using namespace std;

#define ll long long
#define ull unsigned long long

/*------------------------------------------------------------------*/


ifstream f{"maxflow.in"};
ofstream q{"maxflow.out"};

int capacity[1005][1005];
int flow[1005][1005];

int n, m;
bool vis[1005];
vector<int> prec(1005, 0);
vector<int> coada(1005, 0);
vector<int> graph[1005];

bool bfs(int source, int destination)
{
   int top;
   int leftQ, rightQ;

   memset(vis, false, sizeof(vis));

   vis[source] = true;
   prec[source] = source;
   coada[1] = source;

   leftQ = 1;
   rightQ = 1;

   while (leftQ <= rightQ)
   {
      top = coada[leftQ];
      for (auto& vecin : graph[top])
      {
         if (!vis[vecin] && capacity[top][vecin] != flow[top][vecin])
         {
            vis[vecin] = true;
            rightQ++;
            coada[rightQ] = vecin;
            prec[vecin] = top;
            if (vecin == destination) // we found a path
               return true;
         }
      }
      leftQ++;
   }

   return false;
}

int FordFulkerson(int source, int destination)
{
   int maxFlow = 0;
   int localFlow;
   int node;

   while (bfs(source, destination))
   {
      localFlow = numeric_limits<int>::max();
      node = destination;

      while (node != source)
      {
         localFlow = min(localFlow, capacity[prec[node]][node] - flow[prec[node]][node]);
         node = prec[node];
      }

      node = destination;
      while(node != source)
      {
         flow[prec[node]][node] += localFlow;
         flow[node][prec[node]] -= localFlow;
         node = prec[node];
      }

      maxFlow += localFlow;
   }

   return maxFlow;
}

int main()
{
   ios_base::sync_with_stdio(false) , cin.tie(nullptr) , cout.tie(nullptr);

   f >> n >> m;
   int x, y, cap;

   for (int i = 1; i <= m; ++i)
   {
      f >> x >> y >> cap;
      graph[x].push_back(y);
      graph[y].push_back(x);

      capacity[x][y] = cap;
   }
   
   q << FordFulkerson(1, n);

   f.close();
   q.close();
   return 0;
}