#include<fstream>
#include<vector>
#include<queue>
#include<cstring>
#include<cmath>

#define NMAX 1000 + 5
#define child v[nod][i]
#define INF 0x3f3f3f3f
#define min(a,b) a < b ? a : b

using namespace std;

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



vector<int> v[NMAX];

int capacity[NMAX][NMAX];
int flux[NMAX][NMAX];
int viz[NMAX];
int tata[NMAX];


int n,m;
int source,target;



void read_data()
{

    int node1,node2,flow;
    int i;

    in>>n>>m;

    for(i = 0 ; i < m ; ++i)
    {
        in>>node1>>node2>>flow;
        v[node1].push_back(node2);
        v[node2].push_back(node1);
        capacity[node1][node2]+=flow;

    }

}
int cnt ;

bool BFS()
{
    int nod;
    queue<int> q;

    memset(viz,0,sizeof(viz));

    viz[1]=1;
    q.push(source);


    while(!q.empty())
    {
        nod = q.front();
        q.pop();

        for(int i = 0 ; i < v[nod].size(); ++i)
        {
            int b = child;

            if( capacity[nod][child] == flux[nod][child]   || viz[child])
                continue;

            viz[child] = 1;
            tata[child] = nod;
            q.push(child);
            if(child == target)
                return true;

        }


    }

    return viz[n];

}


void max_flow(int s,int t)
{

    long fmax ;
    long fmin;
    int nod;
    source = s;
    target = t;


    for (fmax = 0 ; BFS() ; )
    {
        ++cnt;

        for(int i = 0 ; i < v[target].size(); ++i)
        {
            fmin = INF;

            nod = v[target][i];
            if(flux[nod][target] == capacity[nod][target] || !viz[nod])
                continue;

            tata[target]= nod;

            for(int j = target; j != source; j = tata[j])
                fmin = min(fmin,capacity[tata[j]][j]-flux[tata[j]][j]);

            fmax +=fmin;

            for(int j = target; j!=source; j=tata[j])
            {
                flux[tata[j]][j] +=fmin;
                flux[j][tata[j]] -=fmin;
            }
        }

    }

    out<<fmax;

}




int main()
{
    int fmax;
    read_data();
    max_flow(1,n);


    return 0;

}