#include<fstream>
#include<vector>
#include<queue>
using namespace std;

class Graph
{
private:

    const int INF = 1 << 30;
    struct muchie
    {
        int to,ind,flow,cap;
    };

    vector<vector<muchie>> ad;
    vector<int> dist;
    int n,s,t;

    bool bfs()
    {
        fill(dist.begin(),dist.end(),INF);
        queue<int> q; q.push(s);

        dist[s] = 0;

        while(!q.empty())
            {
                int v = q.front(); q.pop();
                for(auto &it : ad[v])
                    {
                        if(it.flow >= it.cap || dist[it.to] != INF)
                            continue;

                        dist[it.to] = dist[v] + 1;
                        q.push(it.to);
                    }
            }

        return (dist[t] != INF);
    }

    int dfs(int nod,int flux)
    {
        if(nod == t) return flux;
        for(int i = 0 ; i < (int)ad[nod].size() ; i++)
            {
                muchie &m = ad[nod][i];
                if(m.cap <= m.flow || dist[m.to] != dist[nod] + 1) continue;
                int delta = dfs(m.to,min(m.cap - m.flow,flux));
                if(delta > 0)
                    {
                        m.flow += delta;
                        ad[m.to][m.ind].flow -= delta;

                        return delta;
                    }
            }

        return 0;
    }

public:

    Graph(int _n,int _s,int _t)
    {
        ad.resize(_n + 1);
        dist.resize(_n + 1);
        n = _n,s = _s,t = _t;
    }

    void add(int a,int b,int c)
    {
        ad[a].push_back({b,(int)ad[b].size(),0,c});
        ad[b].push_back({a,(int)ad[a].size() - 1,0,0});
    }

    int maxflow()
    {

        int ans = 0;
        while(bfs())
            {
                int delta = dfs(s,INF);
                while(delta > 0)
                    {
                        ans += delta;
                        delta = dfs(s,INF);
                    }

            }
        return ans;
    }

};

int main()
{
    ifstream fin("maxflow.in");
    ofstream fout("maxflow.out");

    int a,b,c,d; fin >> a >> d;
    Graph graph(a,1,a);
    while(d--)
        {
            fin >> a >> b >> c;
            graph.add(a,b,c);
        }


    fout << graph.maxflow();

}