#include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<algorithm>

 #include<vector>

 #include<queue>

 using namespace std;

 const int maxn = ;

 const int INF = 1e9 + ;

 struct edge

 {

     int from, to, cap, flow;//分别是起点，终点，容量，流量

     edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f){}

 };

 int n, m;//n为点数，m为边数

 vector<edge>e;//保存所有边的信息

 vector<int>G[maxn];//邻接表，G[i][j]保存节点i的第j条边在e数组里面的编号

 int a[maxn];//每个点目前流经的水量

 int p[maxn];//p[i]从原点s到终点t的节点i的前一条边的编号

 void init(int n)

 {

     for(int i = ; i <= n; i++)G[i].clear();

     e.clear();

 }

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

 {

     e.push_back(edge(u, v, c, ));//正向边

     e.push_back(edge(v, u, , ));//反向边，容量为0

     m = e.size();

     G[u].push_back(m - );

     G[v].push_back(m - );

 }

 int Maxflow(int s, int t)//起点为s，终点为t

 {

     int flow = ;

     for(;;)

     {

         memset(a, , sizeof(a));//从原点s开始放水，最初每个点的水量都为0

         queue<int>Q;//BFS拓展队列

         Q.push(s);

         a[s] = INF;//原点的水设置成INF

         while(!Q.empty())

         {

             int x = Q.front();//取出目前水流到的节点

             Q.pop();

             for(int i = ; i < G[x].size(); i++)//所有邻接节点

             {

                 edge& now = e[G[x][i]];

                 if(!a[now.to] && now.cap > now.flow)

                     //a[i]为0表示i点还未流到

                     //now.cap > now.flow 说明这条路还没流满

                     //同时满足这两个条件，水流可以流过这条路

                 {

                     p[now.to] = G[x][i];//反向记录路径

                     a[now.to] = min(a[x], now.cap - now.flow);

                     //流到下一点的水量为上一点的水量或者路径上还可以流的最大流量，这两者取最小值

                     Q.push(now.to);//将下一个节点入队列

                 }

             }

             if(a[t])break;//如果已经流到了终点t，退出本次找增广路

         }

         if(!a[t])break;//如果所有路都已经试过，水不能流到终点，说明已经没有增广路，已经是最大流

         for(int u = t; u != s; u = e[p[u]].from)//反向记录路径

         {

             e[p[u]].flow += a[t];//路径上所有正向边的流量增加流到终点的流量

             e[p[u]^].flow -= a[t];//路径上所有反向边的流量减少流到终点的流量

         }

         flow += a[t];//最大流加上本次流到终点的流量

     }

     return flow;

 }

 int main()

 {

     int M, N;

     while(cin >> M >> N)

     {

         n = N;

         int u, v, c;

         init(n);

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

         {

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

             addedge(u, v, c);

         }

         cout<<Maxflow(, n)<<endl;

     }

     return ;

 }