#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

ifstream fin("fmcm.in");
ofstream fout("fmcm.out");
vector<int> dist; 
vector<int> tata, distInit, distNoua;
vector<bool> viz;
vector<vector<int>> cost, capacitate, la;
int n, s, d, m, flux;
queue<int> q;
priority_queue<pair<int, int>> pq; 

void BellmanFord()
{
    for (int i = 0; i <= n; ++i)
        distInit[i] = INT_MAX;

    q.push(s);
    viz[s] = true;
    distInit[s] = 0;
    while (!q.empty())
    {
        int nod = q.front();
        q.pop();
        viz[nod] = false;
        for (int i : la[nod])
        {
            if (capacitate[nod][i] && distInit[nod] + cost[nod][i] < distInit[i])
            {
                distInit[i] = distInit[nod] + cost[nod][i];
                if (!viz[i])
                {
                    q.push(i);
                    viz[i] = true;
                }
            }
        }
    }

}
bool Dijkstra()
{
    for (int i = 0; i <= n; ++i)
        dist[i] = INT_MAX;

    dist[s] = 0;
    distNoua[s] = 0;
    pq.push({ 0,s });
    while (!pq.empty())
    {
        int costCurent = -pq.top().first;
        int nod = pq.top().second;
        pq.pop();
        if (dist[nod] != costCurent)
            continue;

        for (int i : la[nod])
        {
            if (capacitate[nod][i])
            {
                int distanta = costCurent + cost[nod][i];
                distanta += distInit[nod] - distInit[i];
                if (distanta < dist[i])
                {
                    dist[i] = distanta;
                    distNoua[i] = distNoua[nod] + cost[nod][i];
                    tata[i] = nod;
                    pq.push({ -dist[i],i });
                }
            }
        }
    }

    //actualizarea distantelor
    for (int i = 1; i <= n; ++i)
        distInit[i] = distNoua[i];

    if (dist[d] == INT_MAX)
        return false;

    int minim = INT_MAX, sol = 0;
    int nod = d;
    while (nod != s)
    {
        minim = min(minim, capacitate[tata[nod]][nod]);
        sol += cost[tata[nod]][nod];
        nod = tata[nod];
    }
    flux = flux + sol * minim;
    nod = d;
    while (nod != s)
    {
        capacitate[tata[nod]][nod] -= minim;
        capacitate[nod][tata[nod]] += minim;
        nod = tata[nod];
    }
    return true;

}
int main()
{
    fin >> n >> m >> s >> d;
    int x, y, c, z;
    for (int i = 0; i < m; ++i)
    {
        fin >> x >> y >> c >> z;
        la[x].push_back(y);
        la[y].push_back(x);
        capacitate[x][y] = c;
        cost[x][y] = z;
        cost[y][x] = -z;
    }

    fin.close();
    BellmanFord();
    while (Dijkstra());
    fout << flux;
    fout.close();
    return 0;
}