#include <bits/stdc++.h>
#define maxN 352
#define ll long long
#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 cmp
{
    bool operator() (const int &x, const int &y)
    {
        return (Dist[x] > Dist[y]);
    }
};
priority_queue < int, vector < int >, cmp > H;
queue < int > q;
bool inq[maxN];
bool vis[maxN];
ll 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);
                }
            }
    }
}
bool Dijkstra()
{
    int i;
    for (i = 1; i <= n; ++ i)
    {
        Dist[i] = inf;
        vis[i] = 0;
        prv[i] = -1;
    }
    Dist[s] = Real_Dist[s] = 0;
    H.push(s);
    vis[s] = 1;
    while (!H.empty())
    {
        int i, x = H.top(), nod;
        H.pop();
        vis[x] = 0;
        for (i = 0; i < V[x].size(); ++ i)
            if (c[x][nod = V[x][i]] && 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];
                if (!vis[nod])
                {
                    H.push(nod);
                    vis[nod] = 1;
                }
                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 += 1LL * vmin * Real_Dist[d];
    return 1;
}
void solve()
{
    BellmanFord();
    while (Dijkstra());
}
void write()
{
    freopen("fmcm.out", "w", stdout);
    printf("%lld\n", ans);
}
int main()
{
    read();
    solve();
    write();
    return 0;
}