#include <bits/stdc++.h>

using namespace std;

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

int n, m, src, dst, maxflow;
vector <vector <int>> adj;
vector <int> tata, dist;
vector <bool> vizitat;
int cap[355][355], cost[355][355];


int bellman_ford()  //Alg. Bellman Ford
{
    queue <int> q;
    vizitat.assign(n+1, false);
    dist.assign(n+1, INT_MAX);

    q.push(src);
    vizitat[src] = true;
    tata[src] = src;
    dist[src] = 0;

    while(!q.empty())
    {
        int node = q.front();
        q.pop();
        vizitat[node] = false;
        for(auto vecin : adj[node])
        {
            if(cap[node][vecin] > 0 && dist[vecin] > dist[node] + cost[node][vecin])
            {
                dist[vecin] = dist[node] + cost[node][vecin];
                tata[vecin] = node;
                if(!vizitat[vecin])
                {
                    q.push(vecin);
                    vizitat[vecin] = true;
                }
            }
        }
    }
    return dist[dst];
}

int main()
{
    int a, b, c, d, i;
    f >> n >> m >> src >> dst;
    adj.reserve(n+1);
    tata.assign(n+1, 0);

    for(i = 0; i < m; i++)
    {
        f >> a >> b >> c >> d;
        adj[a].push_back(b);
        adj[b].push_back(a);
        cap[a][b] = c;
        cost[a][b] = d;
        cost[b][a] = -d;
    }

    while(true)
    {
        int suma = bellman_ford();

        if(suma == INT_MAX)
            break;

        int flow = INT_MAX;
        for(int node = dst; node != src; node = tata[node])
            flow = min(flow, cap[tata[node]][node]);

        for(int node = dst; node != src; node = tata[node]) {
            cap[tata[node]][node] -= flow;
            cap[node][tata[node]] += flow;
        }
        maxflow += flow * suma;
    }
    g << maxflow;
    return 0;
}