#include <bits/stdc++.h>

using namespace std;

ifstream f("maxflow.in");
ofstream g("maxflow.out");

const int NMAX = 1e3 + 5;

int N, M, x, y, z;

int F[NMAX][NMAX], C[NMAX][NMAX];

int T[NMAX];

bool Sel[NMAX];

vector < int > G[NMAX];

static inline void Add_Edge (int u, int v, int c)
{
    C[u][v] = c;

    G[u].push_back(v);
    G[v].push_back(u);

    return;
}

static inline void Read ()
{
    f.tie(NULL);

    f >> N >> M;

    for(int i = 1; i <= M; ++i)
    {
        f >> x >> y >> z;

        Add_Edge(x, y, z);
    }

    return;
}

static inline bool BFS (int S, int D)
{
    for(int i = 1; i <= N; ++i)
        T[i] = -1, Sel[i] = 0;

    T[S] = 0;
    Sel[S] = 0;

    queue < int > Q;

    Q.push(S);

    while(!Q.empty())
    {
        int Node = Q.front();
        Q.pop();

        for(auto it : G[Node])
            if(!Sel[it] && F[Node][it] < C[Node][it])
            {
                T[it] = Node;
                Sel[it] = 1;

                if(it == D)
                    return 1;

                Q.push(it);
            }
    }

    return 0;
}

static inline int Flow (int S, int D)
{
    int ans = 0;

    while(BFS(S, D))
    {
        for(auto it : G[D])
            if(T[it] != -1)
            {
                int Node = it;

                int Min = C[it][D] - F[it][D];

                while(Node != S)
                {
                    int Dad = T[Node];

                    Min = min(Min, C[Dad][Node] - F[Dad][Node]);

                    Node = Dad;
                }

                F[it][D] += Min;
                F[D][it] -= Min;

                ans += Min;

                Node = it;

                while(Node != S)
                {
                    int Dad = T[Node];

                    F[Dad][Node] += Min;
                    F[Node][Dad] -= Min;

                    Node = Dad;
                }
            }
    }

    return ans;
}

int main()
{
    Read();

    g << Flow(1, N) << '\n';

    return 0;
}