#include <fstream>
#include <vector>
#include <cstring>
#include <string>
#include <queue>
#include <climits>
#define NMAX 1024
#define pb push_back
#define INF INT_MAX
using namespace std;

ifstream f("maxflow.in");
ofstream g("maxflow.out");

int n, m;
vector<int> G[NMAX];
int flow_cap[NMAX][NMAX];
bool visited[NMAX];
int parent[NMAX];

void read_data(){
    f >> n >> m;
    for(int i = 1; i<=m; i++){
        int x, y, c;
        f >> x >> y >> c;
        G[x].pb(y);
        G[y].pb(x);
        flow_cap[x][y] += c;
    }
}


bool bfs(int source, int dest){
    memset(visited, false, sizeof(visited));
    memset(parent, 0, sizeof(parent));
    visited[source] = true;
    parent[source] = -1;
    queue<int> q;
    q.push(source);
    while(!q.empty()){
        int node = q.front();
        q.pop();
        if(node == dest){
            continue;
        }
        for(const auto& adj : G[node]){
            if(!visited[adj] && flow_cap[node][adj] > 0){
                q.push(adj);
                visited[adj] = true;
                parent[adj] = node;
            }
        }
    }
    return visited[dest];
}

int get_flow(int source, int dest){
    int max_flow = 0, min_cap;
    while(bfs(source, dest)){
        for(const auto& curr_node : G[dest]){
            if(!visited[curr_node] || flow_cap[curr_node][dest] <= 0){
                continue;
            }
            min_cap = INF;
            parent[dest] = curr_node;
            for(int i = dest; i != source; i = parent[i]){
                min_cap = min(min_cap, flow_cap[parent[i]][i]);
            }

            for(int i = dest; i != source; i = parent[i]){
                flow_cap[parent[i]][i] -= min_cap;
                flow_cap[i][parent[i]] += min_cap;
            }
            max_flow += min_cap;
        }
    }
    return max_flow;
}

int main(){
    read_data();

    g << get_flow(1, n);
    return 0;
}