/* 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;
};

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

    MaxFlow flowSolver;

    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; ++i) {
        int xx, yy, cc;
        scanf("%d%d%d", &xx, &yy, &cc);
        flowSolver.addEdge(xx, yy, cc);
    }

    printf("%d", flowSolver.solve(1, n));
    return 0;
}