#include<stdio.h>

#include<string.h>

#include<queue>

#include<algorithm>

using namespace std;

#define INF 0xfffffff

#define N 220

int maps[N][N], pre[N], ans;

bool bfs(int s, int e)

{

    memset(pre, , sizeof(pre));

    queue<int>Q;

    Q.push(s);

    while(Q.size())

    {

        int i = Q.front();

        Q.pop();

        if(i == e)

            return true;

        for(int j=; j<=e; j++)

        {

            if(pre[j]== && maps[i][j] > )

            {

                pre[j] = i;

                Q.push(j);

            }

        }

    }

    return false;

}

void EK(int s, int e)

{

    while(bfs(s, e))

    {

        int Min = INF;

        for(int i=e; i!=s; i=pre[i])

            Min=min(maps[pre[i]][i], Min);

         for(int i=e; i!=s; i=pre[i])

         {

             maps[pre[i]][i]-=Min;

             maps[i][pre[i]]+=Min;

         }

         ans+=Min;

    }

}

int main()

{

    int n, m, x, y,c;

    while(scanf("%d%d", &m, &n)!=EOF)

    {

        memset(maps, , sizeof(maps));

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

        {

            scanf("%d%d%d", &x, &y, &c);

            maps[x][y] += c;

        }

        ans = ;

        EK(, n);

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

    }

    return ;

}

#include<stdio.h>

#include<string.h>

#include<queue>

#include<algorithm>

using namespace std;

#define N 220

#define INF 0xfffffff

int n, ans, Head[N], cnt, Layer[N];

struct Edge

{

    int v, flow, next;

} e[*N];

void Add(int u, int v, int flow)

{

    e[cnt].v = v;

    e[cnt].flow = flow;

    e[cnt].next = Head[u];

    Head[u] = cnt++;

}

bool bfs(int S, int E)

{

    memset(Layer, , sizeof(Layer));

    Layer[S] = ;

    queue<int>Q;

    Q.push(S);

    int p, q;

    while(!Q.empty())

    {

        p = Q.front();

        Q.pop();

        if(p == E)return true;

        for(int i=Head[p]; i!=-; i=e[i].next)

        {

            q = e[i].v;

            if(!Layer[q] && e[i].flow)

            {

                Layer[q] = Layer[p]+;

                Q.push(q);

            }

        }

    }

    return false;

}

int dfs(int u, int MaxFlow, int E)

{

    if(u == E)return MaxFlow;

    int  uflow=;

    for(int i=Head[u]; i!=-; i=e[i].next)

    {

        int v = e[i].v;

        if(Layer[v]==Layer[u]+ && e[i].flow)

        {

            int flow = min(e[i].flow, MaxFlow - uflow);

            flow = dfs(v, flow, E);

            e[i].flow -= flow;

            e[i^].flow += flow;

            uflow += flow;

            if(uflow==MaxFlow)break;

        }

    }

    if(uflow==)

        Layer[u]=;

    return uflow;

}

void Dinic()

{

    while(bfs(, n))

    {

        ans+=dfs(, INF, n);

    }

}

int main()

{

    int a, b, flow, m;

    while(scanf("%d%d", &m, &n)!=EOF)

    {

        memset(Head, -, sizeof(Head));

        cnt = ;

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

        {

            scanf("%d%d%d", &a, &b, &flow);

            Add(a, b, flow);

            Add(b, a, );

        }

        ans = ;

        Dinic();

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

    }

    return ;

}