#include <bits/stdc++.h>
#define Nmax 1001

using namespace std;

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

int flow,min_flow;
int Flow[Nmax][Nmax],Capacity[Nmax][Nmax];
int parent[Nmax];
bitset <Nmax> vis;
list <int> G[Nmax];
queue <int> q;
int N,M;

void read_data(){

    f>>N>>M;

    for(int x,y,z,i=1;i<=M;i++){

        f>>x>>y>>z;
        G[x].push_back(y);
        G[y].push_back(x);
        Capacity[x][y]=z;
    }
}

bool BFS(){

    q.push(1);
    vis.reset();
    vis[1]=true;

    int node;
    while(!q.empty()){

        node=q.front();
        q.pop();

        if(node==N) continue;

        for(const auto &it:G[node])
            if(!vis[it] and Flow[node][it]!=Capacity[node][it]){

                parent[it]=node;
                q.push(it);
                vis[it]=true;
            }
    }

    return vis[N];
}

void Edmonds_Karp(){

    int node;

    while(BFS())
        for(const auto &it:G[N])
            if(vis[it] and Flow[it][N]!=Capacity[it][N]){

                min_flow=INT_MAX;
                parent[N]=it;

                for(node=N;node!=1;node=parent[node])
                    min_flow=min(min_flow,Capacity[parent[node]][node]-Flow[parent[node]][node]);

                flow+=min_flow;

                if(min_flow)
                    for(node=N;node!=1;node=parent[node]){

                        Flow[parent[node]][node]+=min_flow;
                        Flow[node][parent[node]]-=min_flow;
                    }
            }

    g<<flow;
}

int main(){

    read_data();
    Edmonds_Karp();

    return 0;
}