#include <bits/stdc++.h>
#define maxN 352
#define inf 2000000000
using namespace std;
int n, m, s, d, D[maxN], prv[maxN], cost[maxN][maxN], c[maxN][maxN], Dist[maxN], Real_Dist[maxN];
vector < int > V[maxN];
struct pq
{
    int x, y;
    bool operator < (const pq & e) const
    {
        return Dist[x] > Dist[e.x];
    }
};
priority_queue < pq > H;
queue < int > q;
bool inq[maxN];
bool vis[maxN];
int ans;
void read()
{
    int i;
    freopen("fmcm.in", "r", stdin);
    scanf("%d %d %d %d", &n, &m, &s, &d);
    for (i = 1; i <= m; ++ i)
    {
        int x, y, z, C;
        scanf("%d %d %d %d", &x, &y, &C, &z);
        V[x].push_back(y);
        V[y].push_back(x);
        cost[x][y] = z;
        cost[y][x] = -z;
        c[x][y] = C;
    }
}
void BellmanFord()
{
    int i, j;
    for (i = 1; i <= n; ++ i)
        D[i] = inf;

    memset(inq, 0, sizeof(inq));
    D[s] = 0;
    inq[s] = 1;
    q.push(s);
    while (!q.empty())
    {
        int nod, x = q.front();
        inq[x] = 0;
        q.pop();
        for (i = 0; i < V[x].size(); ++ i)
            if (c[x][nod = V[x][i]] > 0 && D[nod] > D[x] + cost[x][nod])
            {
                D[nod] = D[x] + cost[x][nod];
                prv[nod] = x;
                if (!inq[nod])
                {
                    inq[nod] = 1;
                    q.push(nod);
                }
            }
    }
}
inline bool Dijkstra()
{
    int i;
    for (i = 1; i <= n; ++ i)
    {
        Dist[i] = inf;
        vis[i] = 0;
        prv[i] = -1;
    }
    pq el;
    el.x = s; el.y = 0;
    Dist[s] = Real_Dist[s] = 0;
    H.push(el); vis[s] = 1;
    while (!H.empty())
    {
        int i;
        el = H.top();
        int x = el.x;
        H.pop();
        if (el.y != Dist[x])
            continue;
        vector<int> :: iterator nod;
         for (nod = V[x].begin(); nod != V[x].end(); ++ nod)
            if (c[x][*nod] && Dist[*nod] > Dist[x] + cost[x][*nod] + D[x] - D[*nod])
            {
                Dist[*nod] = Dist[x] + cost[x][*nod] + D[x] - D[*nod];
                Real_Dist[*nod] = Real_Dist[x] + cost[x][*nod];
                pq a; a.x = *nod;
                    a.y = Dist[*nod];
                    H.push(a);

                prv[*nod] = x;
            }
    }
    memcpy(D, Real_Dist, sizeof(Real_Dist));
    if (Dist[d] == inf)
        return 0;
    int vmin = inf;
    for (i = d; i != s; i = prv[i])
        if (vmin > c[prv[i]][i])
            vmin = c[prv[i]][i];
    for (i = d; i != s; i = prv[i])
    {
        c[i][prv[i]] += vmin;
        c[prv[i]][i] -= vmin;
    }
    ans += vmin * Real_Dist[d];
    return 1;
}
void solve()
{
    BellmanFord();
    while (Dijkstra());
}
void write()
{
    freopen("fmcm.out", "w", stdout);
    printf("%d\n", ans);
}
int main()
{
    read();
    solve();
    write();
    return 0;
}