#include <fstream>
#include <vector>
#include <queue>

using namespace std;

ifstream fin("fmcm.in");
ofstream fout("fmcm.out");

const int INF = (1LL << 31) - 1;
int n, m, S, D, x, y, z, t, i, TOTAL, flux, mini, costmin, T[360], c[360][360], cost[360][360], f[360][360], drum[360];
vector<int > G[360];
queue<int > q;
bool ok[360];
struct cmp
{
    bool operator()(int x, int y)
    {
        return drum[x] < drum[y];
    }
};
priority_queue<int, vector<int >, cmp> h;

static inline void Bellman()
{
    for (int i = 1; i <= n; ++i)
        drum[i] = INF, ok[i] = false;
    drum[S] = 0;
    ok[S] = true;
    q.push(S);
    while (!q.empty())
    {
        int nod = q.front();
        ok[nod] = false;
        q.pop();
        for (auto it : G[nod])
            if (c[nod][it] > f[nod][it] && drum[nod] + cost[nod][it] < drum[it])
            {
                drum[it] = drum[nod] + cost[nod][it];
                if (!ok[it])
                {
                    q.push(it);
                    ok[it] = true;
                }
            }
    }
    TOTAL = drum[D];
}

static inline int Dijkstra()
{
    for (int i = 1; i <= n; ++i)
        if (drum[i] != INF)
            for (auto it : G[i])
                if (drum[it] != INF)
                    cost[i][it] += drum[i] - drum[it];
    for (int i = 1; i <= n; ++i)
        drum[i] = INF, ok[i] = false;
    drum[S] = 0;
    h.push(S);
    ok[S] = true;
    while (!h.empty())
    {
        int nod = h.top();
        h.pop();
        ok[nod] = false;
        for (auto it : G[nod])
            if (c[nod][it] > f[nod][it] && drum[nod] + cost[nod][it] < drum[it])
            {
                drum[it] = drum[nod] + cost[nod][it];
                T[it] = nod;
                if (!ok[it])
                {
                    h.push(it);
                    ok[it] = true;
                }
            }
    }
    if (drum[D] != INF)
        return 1;
    return 0;
}

int main()
{
    ios::sync_with_stdio(false);
    fin.tie(nullptr);
    fin >> n >> m >> S >> D;
    for (i = 1; i <= m; ++i)
    {
        fin >> x >> y >> z >> t;
        G[x].push_back(y);
        G[y].push_back(x);
        c[x][y] = z;
        cost[x][y] = t;
        cost[y][x] = -t;
    }
    Bellman();
    while (Dijkstra())
    {
        mini = 0;
        flux = INF;
        int nod = D;
        while (nod != S)
        {
            if (c[T[nod]][nod] - f[T[nod]][nod] < flux)
                flux = c[T[nod]][nod] - f[T[nod]][nod];
            nod = T[nod];
        }
        if (flux <= 0)
            continue;
        nod = D;
        while (nod != S)
        {
            f[T[nod]][nod] += flux;
            f[nod][T[nod]] -= flux;
            nod = T[nod];
        }
        TOTAL += drum[D];
        costmin += flux * TOTAL;
    }
    fout << costmin;
    return 0;
}