/* Mai du-te-n gatul ma-tii
   Mai du-te-n pizda ma-tii
   Floooow
   Floooooooooow....

*/

#include <bits/stdc++.h>

using namespace std;

const int kNMax = 1024;

class MaxFlow {
  public:
    void addEdge(int xx, int yy, int cap) {
        int index1 = m_edges.size();
        int index2 = m_edges.size() + 1;
        m_edges.push_back(flow_edge(xx, yy, cap, index2));
        m_edges.push_back(flow_edge(yy, xx, 0, index1));
        m_graph[xx].push_back(index1);
        m_graph[yy].push_back(index2);
    }

    int solve(int source, int sink) {
        answer = 0;
        int myFlow;
        do {
            memset(used, 0, sizeof(used));
            myFlow = dfs(source, sink, 1 << 30);
            answer += myFlow;
        } while (myFlow);
        return answer;
    }

  private:
    struct flow_edge {
        int from;
        int to;
        int cap;
        int flow;
        int rev_edge;

        flow_edge() {

        }

        flow_edge(int _from, int _to, int _cap, int _rev) {
            from = _from;
            to = _to;
            cap = _cap;
            flow = 0;
            rev_edge = _rev;
        }
    };

    int dfs(int source, int sink, int myFlow) {
        if (source == sink)
            return myFlow;

        used[source] = 1;
        vector <int> :: iterator it;
        vector <int> m_list;
        for (it = m_graph[source].begin(); it != m_graph[source].end(); ++it)
            m_list.push_back(*it);
        random_shuffle(m_list.begin(), m_list.end());
        for (it = m_list.begin(); it != m_list.end(); ++it) {
            flow_edge myEdge = m_edges[*it];
            if (myEdge.flow < myEdge.cap && !used[myEdge.to]) {
                int ret = dfs(myEdge.to, sink, min(myFlow, myEdge.cap - myEdge.flow));
                if (ret > 0) {
                    m_edges[*it].flow += ret;
                    m_edges[myEdge.rev_edge].flow -= ret;
                    return ret;
                }
            }
        }
        return 0;
    }

    vector <int> m_graph[kNMax];
    vector <flow_edge> m_edges;
    bool used[kNMax];
    int answer;
};

const int SIZE = 32000;

class myIfstream {
private :
    char buffer [SIZE];
    int cursor = 0;
    FILE *input;
    void advance () {
        ++ cursor;
        if (cursor == SIZE) {
            cursor = 0;
            fread (buffer, 1, SIZE, input);
        }
    }
public :
    myIfstream ();
    myIfstream (char *inputName) {
        input = fopen (inputName, "r");
        cursor = 0;
        fread (buffer, 1, SIZE, input);
    }
    myIfstream &operator >> (int &value) {
        value = 0;
        while (!(buffer [cursor] >= '0'&& buffer [cursor] <= '9'))
            advance ();
        while (buffer [cursor] >= '0' && buffer [cursor] <= '9') {
            value = value * 10 + buffer [cursor] - '0';
            advance ();
        }
        return *this;
    }
};

myIfstream fin ( "maxflow.in" ) ;
ofstream fout ( "maxflow.out" ) ;

int main() {
    //freopen("maxflow.in", "r", stdin);
    //freopen("maxflow.out", "w", stdout);

    MaxFlow flowSolver;

    int n, m;
    fin >> n >> m ;
    for (int i = 1; i <= m; ++i) {
        int xx, yy, cc;
        fin >> xx >> yy >> cc ;
        flowSolver.addEdge(xx, yy, cc);
    }

    fout << flowSolver.solve(1, n) ;
    return 0;
}