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

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

class Graph
{
    private: struct edge{int to,cap,flow,id;};
    int s,t; vector<vector<edge>> vecini;
    vector<int> dist,rem;

    bool bfs()
    {
        fill(dist.begin(),dist.end(),0); dist[s] = 1;
        queue<int> q; q.push(s);

        while(!q.empty())
            {
                int v = q.front(); q.pop();
                for(auto it : vecini[v])
                    {
                        if((it.cap - it.flow) > 0 && !dist[it.to])
                            {
                                dist[it.to] = dist[v] + 1;
                                q.push(it.to);
                            }
                    }
            }

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

    int dfs(int a,int f)
    {
        if(a == t) return f;
        for(int &h = rem[a]; h < vecini[a].size() ; h++)
            {
                edge &m = vecini[a][h];
                if((m.cap - m.flow) > 0 && dist[m.to] == dist[a] + 1)
                    {
                        int go = dfs(m.to,min(f,m.cap - m.flow));
                        if(go)
                            {
                                m.flow += go;
                                vecini[m.to][m.id].flow -= go;
                                return go;
                            }
                    }
            }

        return 0;
    }

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

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

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

        return ans;
    }
};

int main()
{
    int n,m,a,b,c; cin >> n >> m;
    Graph graph(n,1,n); while(m--)
    {
        cin >> a >> b >> c;
        graph.add(a,b,c);
    }

    cout << graph.maxflow();
}