#include <bits/stdc++.h>
//#pragma GCC optimize ("03")
#define FastIO ios_base::sync_with_stdio(false) , cin.tie(0) , cout.tie(0)
#define FILES freopen("maxflow.in" , "r" , stdin) , freopen("maxflow.out" , "w" , stdout)
#define ll long long
#define ull unsigned long long
#define ld long double
#define eb emplace_back
#define pb push_back
#define qwerty1 first
#define qwerty2 second
#define qwerty3 -> first
#define qwerty4 -> second
#define umap unordered_map
#define uset unordered_set
#define pii pair < ll , ll >
#define pq priority_queue
#define dbg(x) cerr << #x << ": " << x << '\n'
#define int long long

namespace FastRead
{
    char __buff[5000];ll __lg = 0 , __p = 0;
    char nc()
    {
        if(__lg == __p){__lg = fread(__buff , 1 , 5000 , stdin);__p = 0;if(!__lg) return EOF;}
        return __buff[__p++];
    }
    template<class T>void read(T&__x)
    {
        T __sgn = 1; char __c;while(!isdigit(__c = nc()))if(__c == '-')__sgn = -1;
        __x = __c - '0';while(isdigit(__c = nc()))__x = __x * 10 + __c - '0';__x *= __sgn;
    }
}

using namespace FastRead;
using namespace std;
#define int long long

const ll N = 2e5 + 10;
const ll M = 1e9 + 7;
const ld PI = acos(-1);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

struct MaxFlow 
{
    #define N 5005 + 10

    int n , source , sink;
    struct edge {int x , y , cap;};
    vector < edge > edg;
    vector < int > G[N];
    queue < int > q;
    int d[N];
    int ptr[N];

    void add_edge(int x , int y , int cap)
    {
        edg.pb({x , y , cap});
        G[x].pb(edg.size() - 1);
        edg.pb({y , x , 0});
        G[y].pb(edg.size() - 1);
    }

    void init(int n , int source , int sink)    
    {
        this -> n = n;
        this -> source = source;
        this -> sink = sink;

        edg.clear();

        for(int i = 1 ; i <= n ; i++)
            G[i].clear();
    }

    bool bfs()
    {
        for(int i = 1 ; i <= n ; i++)
            d[i] = 0;

        d[source] = 1;
        q.push(source);

        while(q.size())
        {
            int node = q.front();
            q.pop();
            
            for(auto e : G[node])
            {
                int to = node ^ edg[e].x ^ edg[e].y;
                int cap = edg[e].cap;

                if(cap == 0) continue;
                if(d[to]) continue;
                
                d[to] = d[node] + 1;
                q.push(to);
            }
        }

        return d[sink] != 0;
    }

    int dfs(int node , int pushed_flow)
    {
        if(node == sink)
            return pushed_flow;

        for(int &i = ptr[node] ; i < G[node].size() ; i++)
        {
            int e = G[node][i];
            int to = node ^ edg[e].x ^ edg[e].y;
            int cap = edg[e].cap;

            if(d[to] != d[node] + 1)
                continue;

            if(cap == 0)
                continue;

            int f = dfs(to , min(pushed_flow , cap));

            if(f == INT_MAX) continue;

            edg[e].cap -= f;
            edg[e ^ 1].cap += f;
            return f;
        }

        return INT_MAX;
    }

    int max_flow()
    {
        int f = 0;

        while(bfs())
        {
            for(int i = 1 ; i <= n ; i++)
                ptr[i] = 0;

            int flow = 0;

            while((flow = dfs(source , INT_MAX)) != INT_MAX)
                f += flow;
        }

        return f;
    }

}F;

int n , m;

signed main()
{
    FastIO;
	
//    #ifndef ONLINE_JUDGE
		FILES;
//	#endif
    
    cin >> n >> m;

    F.init(n , 1 , n);

    for(int i = 1 ; i <= m ; i++)
    {
        int x , y , cap;
        cin >> x >> y >> cap;
        F.add_edge(x , y , cap);
    }
    
    cout << F.max_flow();

    return 0;
}