#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) < (b)) ? (b) : (a))
//#pragma GCC optimize("O3")
using namespace std;
using namespace __gnu_pbds;
auto random_address = [] { char *p = new char; delete p; return uint64_t(p); };
const uint64_t SEED = chrono::steady_clock::now().time_since_epoch().count() * (random_address() | 1);
mt19937_64 rng(SEED);
typedef tree<
int,
null_type,
less<int>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
ifstream fin("maxflow.in");
ofstream fout("maxflow.out");
struct flow
{
    struct edge
    {
        int to;
        int cap;
    };
    const int INF=(int) 1e9;
    int n;
    vector<edge> edges;
    vector<vector<int>> g;
    vector<int> level;
    vector<int> pt;
    void init(int nn)
    {
        n=nn;
        edges.clear();
        pt.resize(n+1);
        level.resize(n+1);
        g.resize(n+1);
    }
    void add(int a, int b, int c)
    {
        g[a].push_back((int) edges.size());
        g[b].push_back((int) edges.size()+1);
        edges.push_back({b,c});
        edges.push_back({a,0});
    }

    int dfs(int a, int cap)
    {
        if(cap==0||a==n)
            return cap;
        while(pt[a]<(int) g[a].size())
        {
            int i=g[a][pt[a]++];
            if(edges[i].cap&&level[edges[i].to]==1+level[a])
            {
                int b=edges[i].to;
                int x=dfs(b, min(cap,edges[i].cap));
                if(x>0)
                {
                    edges[i].cap-=x;
                    edges[i^1].cap+=x;
                    return x;
                }
            }
        }
        return 0;
    }
    int get()
    {
        int ret=0;
        while(true)
        {
            for(int i=1;i<=n;i++)
            {
                level[i]=-1;
                pt[i]=0;
            }
            level[1]=0;
            queue<int> q;
            q.push(1);
            while(!q.empty())
            {
                int a=q.front();
                q.pop();
                for(auto i:g[a])
                {
                    if(edges[i].cap>0)
                    {
                        int b=edges[i].to;
                        if(level[b]==-1)
                        {
                            level[b]=1+level[a];
                            q.push(b);
                        }
                    }
                }
            }
            if(level[n]==-1)
                break;
            while(true)
            {
                int x=dfs(1,INF);
                if(x==0)
                    break;
                ret+=x;
            }
        }
        return ret;
    }
};
int n,m;
int main()
{
    ios_base::sync_with_stdio(false);
    fin.tie(0);
    fout.tie(0);
    fin>>n>>m;
    flow f;
    f.init(n);
    for(int i=1;i<=m;i++)
    {
        int x,y,z;
        fin>>x>>y>>z;
        f.add(x,y,z);
    }
    fout<<f.get();
    return 0;
}