// VARIANTA 1
// 70/100

//#include <bits/stdc++.h>
//using namespace std;
//
//ifstream f("maxflow.in");
//ofstream g("maxflow.out");
//
//int capacitate_flux[1001][1001];
//int flowPassed[1001][1001];
//vector<int> graf[1001];
//int parList[1001];
//int currentPathC[1001];
//
//int bfs(int start, int end)//breadth first search
//{
//    memset(parList, -1, sizeof(parList));
//    memset(currentPathC, 0, sizeof(currentPathC));
//    queue<int> q;//declare queue vector
//
//    q.push(start);
//    parList[start] = -1;//initialize parlist’s source node
//    currentPathC[start] = 999;//initialize currentpath’s source node
//
//    while(!q.empty())// if q is not empty
//    {
//        int nod_curent = q.front();
//        q.pop();
//        for(int i=0; i < graf[nod_curent].size(); i++)
//        {
//            int to = graf[nod_curent][i];
//            if(parList[to] == -1)
//            {
//                if(capacitate_flux[nod_curent][to] - flowPassed[nod_curent][to] > 0)
//                {
//                    parList[to] = nod_curent;
//                    currentPathC[to] = min(currentPathC[nod_curent], capacitate_flux[nod_curent][to] - flowPassed[nod_curent][to]);
//                    if(to == end)
//                    {
//                        return currentPathC[end];
//                    }
//                    q.push(to);
//                }
//            }
//        }
//    }
//    return 0;
//}
//
//int edmondsKarp(int start, int end)
//{
//    int maxFlow = 0;
//    while(true)
//    {
//        int flow = bfs(start, end);
//        if (flow == 0)
//        {
//            break;
//        }
//        maxFlow += flow;
//        int nod_curent = end;
//        while(nod_curent != start)
//        {
//            int nod_anterior = parList[nod_curent];
//            flowPassed[nod_anterior][nod_curent] += flow;
//            flowPassed[nod_curent][nod_anterior] -= flow;
//            nod_curent = nod_anterior;
//        }
//    }
//    return maxFlow;
//}
//int main()
//{
//    int N, M;
////    cout<<"enter the number of nodes and edges\n";
//    f >> N >> M;
//    int source=1, dest=N;
//
//    for(int ed = 0; ed < M; ed++)
//    {
////        cout<<"enter the start and end vertex along with capacity\n";
//        int from, to, cap;
//        f>>from>>to>>cap;
//        capacitate_flux[from][to] = cap;
//        graf[from].push_back(to);
//        graf[to].push_back(from);
//    }
//    int maxFlow = edmondsKarp(source, dest);
//    g<<maxFlow<<endl;
//}
//
//


// VARIANTA 2

#include <bits/stdc++.h>
using namespace std;

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

int capacity[1001][1001],n,m,flow,max_flow;
vector<int> visited,parent;
vector<vector<int>> v;

bool bfs()
{
    fill(visited.begin(), visited.end(), 0);
    fill(parent.begin(), parent.end(), 0);

    visited[1] = 1;
    parent[1] = 1;
    queue<int> q;
    q.push(1);

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

        q.pop();

        if(nod == n)
            return true;

        for(int i=0; i<v[nod].size(); i++)
        {
            if(!visited[v[nod][i]] && capacity[nod][v[nod][i]] > 0)
            {
                q.push(v[nod][i]);
                parent[v[nod][i]] = nod;
                visited[v[nod][i]] = 1;
            }
        }
    }

    return false;


}

int main()
{
    int a,b,capacitate_flux;
    f>>n>>m;
    visited.resize(n+2, 0);
    parent.resize(n+2, 0);
    v.resize(n+2, {});

    for(int i=1; i<=m; i++)
    {
        f>>b>>capacitate_flux>>a;
        v[b].push_back(capacitate_flux);
        v[capacitate_flux].push_back(b);
        capacity[b][capacitate_flux] = a;
    }

    int reusit = bfs();

    while(reusit)
    {
        for(int i=0; i<v[n].size(); i++)
        {
            if(visited[v[n][i]])
            {
                parent[n] = v[n][i];
                flow = INT_MAX;
                for(int j=n; j!=1; j=parent[j])
                {
                    flow=min(flow, capacity[parent[j]][j]);
                }
                if(flow != 0)
                {
                    for(int j=n; j!=1; j=parent[j])
                    {
                        capacity[parent[j]][j] -= flow;
                        capacity[j][parent[j]] += flow;
                    }
                    max_flow += flow;
                }
            }
        }
        reusit = bfs();
    }
    g<<max_flow;
    return 0;
}







//
////#include <iostream>
////#include <bits/stdc++.h>
////using namespace std;
//////#define V 100
////
////int N;
////int graph[1001][1001];
////int rGraph[1001][1001];
//////int V;
////
/////* Returns true if there is a path from source 's' to sink 't' in
//// * residual graph. Also fills parent[] to store the path */
////bool BFs( int s, int t, int parent[])
////{
////    // Create a visited array and mark all vertices as not visited
////    bool visited[1001];
////    memset(visited, 0, sizeof(visited));
////    // Create a queue, enqueue source vertex and mark source vertex
////    // as visited
////    queue <int> q;
////    q.push(s);
////    visited[s] = true;
////    parent[s] = -1;
////    // Standard BFS Loop
////    while (!q.empty())
////    {
////        int u = q.front();
////        q.pop();
////        for (int v = 0; v < N; v++)
////            if (visited[v] == false && rGraph[u][v] > 0)
////            {
////                q.push(v);
////                parent[v] = u;
////                visited[v] = true;
////            }
////    }
////    // If we reached sink in BFS starting from source, then return
////    // true, else false
////    return visited[t] == true;
////}
////// Returns tne maximum flow from s to t in the given graph
////int fordFulkerson( int s, int t, int N)
////{
////    int u, v;
////    // Create a residual graph and fill the residual graph with
////    // given capacities in the original graph as residual capacities
////    // in residual graph
////    int rGraph[N][N]; // Residual graph where rGraph[i][j] indicates
////    // residual capacity of edge from i to j (if there
////    // is an edge. If rGraph[i][j] is 0, then there is not)
////    for (u = 0; u < N; u++)
////        for (v = 0; v < N; v++)
////            rGraph[u][v] = graph[u][v];
////    int parent[N];  // This array is filled by BFS and to store path
////    int max_flow = 0;  // There is no flow initially
////    // Augment the flow while tere is path from source to sink
////    while (BFs( s, t, parent))
////    {
////        // Find minimum residual capacity of the edges along the
////        // path filled by BFS. Or we can say find the maximum flow
////        // through the path found.
////        int path_flow = INT_MAX;
////        for (v = t; v != s; v = parent[v])
////        {
////            u = parent[v];
////            path_flow = min(path_flow, rGraph[u][v]);
////        }
////        // update residual capacities of the edges and reverse edges
////        // along the path
////        for (v = t; v != s; v = parent[v])
////        {
////            u = parent[v];
////            rGraph[u][v] -= path_flow;
////            rGraph[v][u] += path_flow;
////        }
////        // Add path flow to overall flow
////        max_flow += path_flow;
////    }
////    // Return the overall flow
////    return max_flow;
////}
////
////int main(){
////    int M, x, y, z;
////    int Flux_max;
////
////
////    cin>>N>>M;  // noduri, muchii
////    int graf[N][N];
////
////    for(int i=1;i<=N;i++)
////        for(int j=1;j<=N;j++)
////            graf[i][j]=0;
////
////    for(int i=0;i<M;i++){
////        cin>>x>>y>>z;
////        graf[x][y]=z;
////    }
////
////    for(int i=1;i<=N;i++){
////        for(int j=1;j<=N;j++)
////            cout<<graf[i][j]<<" ";
////        cout<<endl;}
////
////    // 1 sursa, N destinatia
////    Flux_max= fordFulkerson(1,N,N);
////    cout<<Flux_max;
////
////}
////