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

struct Element{
    int num;
    int dist;
    int flow;
    Element(int n, int d) : num(n), dist(d), flow(0) {}
};

class CGraph{
public:
    CGraph(int n, int s, int t){
        table.resize(n);
        istok = s-1;
        stok = t-1;


        visited.resize(table.size(),false);
    }
    void AddEdge(int from, int to, int dist){
        table[from-1].push_back(Element(to-1,dist));
    }

    int solve(){
        int max = 0;
        int sent = dfs(istok,200000);
        while (sent > 0){
            max +=sent;
            for(int i = 0; i < table.size(); i++){
                visited[i] = 0;
            }
            sent = dfs(istok,200000);
        }
        return  max;
    }



private:
    vector<vector<Element>>table;

    int istok;
    int stok;

    vector<bool> visited;

    int dfs(int u, int Cmin){
        if(u == stok){
            return Cmin;
        }
        visited[u] = true;

        for(int i = 0; i < table[u].size();i++){
            Element v = table[u][i];
            if(!visited[v.num] && v.flow < v.dist){
                int delta = dfs(v.num, min(Cmin,v.dist - v.flow));
                if (delta > 0){
                    table[u][i].flow += delta;
                    for(int k = 0; k < table[v.num].size(); k++){
                        if(table[v.num][k].num == u){
                            table[v.num][k].flow -= delta;
                            return delta;
                        }
                    }
                    table[v.num].push_back(Element(u, 0));
                    table[v.num][table[v.num].size()-1].flow -= delta;
                    return delta;
                }
            }
        }
        return 0;
    }
};

int main(){
    ifstream fin("maxflow.in");
    ofstream fout("maxflow.out");
    int n = 0;
    int m = 0;
    fin >> n >> m;
    CGraph g(n, 1, n);
    for(int i = 0; i < m; i++){
        int from = 0; int to = 0; int dist = 0;
        fin >> from >> to >> dist;
        g.AddEdge(from,to,dist);
    }
    fout << g.solve();
    fin.close();
    fout.close();
    return 0;
}