///maxflow

#include <bits/stdc++.h>

#include <iostream>

#include <fstream>

#include <algorithm>

#include <cmath>

#include <vector>

using namespace std;

#define fori for(int i=1;i<=n;++i)

#define forj for(int j=1;j<=n;++j)

void runit(int node)

{

    if(node%2==1)

        return;

    for(int i=1; i<=node; ++i)

        if(i%2==1)

        {

            cout<<0;

            return;

        }

        else

        {

            cout<<1;

        }

    return;

}

#define i0 for(int i=0;i<n;++i)

#define j0 for(int j=0;j<n;++j)

void doit(int node)

{

    if(node%2==1)

        return;

    for(int i=1; i<=node; ++i)

        if(i%2==1)

        {

            cout<<0;

            return;

        }

        else

        {

            cout<<1;

        }

    return;

}

class numere
{

private:

    int S,D;

    int N;

    struct Edge
    {

        int x;

        int flow;

        int cap;

        int rv;

    };

    vector<vector<Edge>> gr;

    vector<int> lvl;

    vector<int> ind;

    bool BFS_level()
    {

        queue<int> q;

        for(int i=1; i<=N; i++)

            lvl[i]=-1;

        q.push(S);

        lvl[S]=0;

        while(!q.empty())
        {

            int node=q.front();

            q.pop();

            for(auto vec:gr[node])
            {

                if(lvl[vec.x]==-1 && vec.flow<vec.cap)
                {

                    lvl[vec.x]=lvl[node]+1;

                    q.push(vec.x);

                }

            }

        }

        if(lvl[D]!=-1)

            return true;

        return false;

    }

    int DFS_sendflow(int node,int curflow)
    {

        if(node==D || curflow==0)

            return curflow;

        for(; ind[node]<gr[node].size(); ind[node]++)
        {

            auto &vec=gr[node][ind[node]];

            if(lvl[vec.x]==lvl[node]+1 && vec.flow<vec.cap)
            {

                int cflow=DFS_sendflow(vec.x,min(curflow,vec.cap-vec.flow));

                if(cflow>0)
                {

                    vec.flow+=cflow;

                    gr[vec.x][vec.rv].flow-=cflow;

                    return cflow;

                }

            }

        }

        return 0;

    }

public:

    numere (int sz,int source,int dest)
    {

        gr.resize(sz+1);

        S=source;

        D=dest;

        N=sz;

        lvl.resize(N+1);

        ind.resize(N+1);

    }

    void AddEdge(int x,int y,int cap)
    {

        gr[x].push_back({y,0,cap,gr[y].size()});

        gr[y].push_back({x,0,0,gr[x].size()-1});

    }

    int getflow()
    {

        int ans=0;

        while(BFS_level())
        {

            for(int i=0; i<=N; i++)

                ind[i]=0;

            int flow;

            while((flow=DFS_sendflow(S,INT_MAX))>0)

                ans+=flow;

        }

        return ans;

    }

};

int main()

{

    FILE*fin,*fout;

    fin=fopen("maxflow.in","r");

    fout=fopen("maxflow.out","w");

    int n,m;

    fscanf(fin,"%d%d",&n,&m);

    numere network(n,1,n);

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

        int x,y,z;

        fscanf(fin,"%d%d%d",&x,&y,&z);

        network.AddEdge(x,y,z);

    }

    fprintf(fout,"%d",network.getflow());

    return 0;

}
////