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

ifstream cin("maxflow.in");
ofstream cout("maxflow.out");

class Graph
{
private:
    struct muchie
    {
        int to,flow,cap,id;
    };

    int n,s,t; vector<int> rem,dist;
    vector<vector<muchie>> muchii;

    bool bfs()
    {
        fill(dist.begin(),dist.end(),0);
        queue<int> q; q.push(s); dist[s] = 1;
        while(!q.empty())
            {
                int v = q.front(); q.pop();
                for(auto it : muchii[v])
                    {
                        if(it.cap - it.flow && !dist[it.to])
                            {
                                dist[it.to] = dist[v] + 1;
                                q.push(it.to);
                            }
                    }
            }

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

    int dfs(int nod,int f)
    {
        if(nod == t) return f;
        for(int &h = rem[nod]; h < muchii[nod].size() ; h++)
            {
                muchie &m = muchii[nod][h];
                if(m.cap - m.flow && dist[nod] + 1 == dist[m.to])
                    {
                        int trie = dfs(m.to,min(f,m.cap - m.flow));
                        if(trie)
                            {
                                m.flow += trie;
                                muchii[m.to][m.id].flow -= trie;
                                return trie;
                            }
                    }
            }

        return 0;
    }

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

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

    void reset(int a,int b)
    {
        s = a;
        t = b;

        for(int i = 1; i <= n ; i++) for(auto &it : muchii[i]) it.flow = 0;
    }

    int maxflow()
    {
        int ans = 0;
        while(bfs())
            {
                fill(rem.begin(),rem.end(),0);
                int delta = dfs(s,1 << 30);
                while(delta)
                    {
                        ans += delta;
                        delta = dfs(s,1 << 30);
                    }
            }

        return ans;
    }



};


int main()
{
    int n,m,a,b,c;
    cin >> n >> m;
    Graph g(n,1,n);
    for(int i = 0 ; i < m ; i++)
        {
            cin >> a >> b >> c;
            g.add(a,b,c);
        }

    cout << g.maxflow();

}