#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#define oo 1e7

using namespace std;

#define MAXN 355

int N, M, S, D;
int C[MAXN][MAXN], Cst[MAXN][MAXN];
vector<int> con[MAXN];
int F, FCst;

int old_d[MAXN]; bool inQ[MAXN];
queue<int> Q;

int d[MAXN], real_d[MAXN], ant[MAXN];
priority_queue<pair<int, int>, vector<pair<int, int> >, greater<pair<int, int> > > H;

inline bool dijkstra()
{
    for(int i=1; i<=N; ++i)
        d[i] = oo;

    d[S] = 0; real_d[S] = 0;
    H.push(make_pair(d[S], S));

    while(!H.empty())
    {
        int cst = H.top().first;
        int nod = H.top().second;
        H.pop();
        if (d[nod] != cst)
            continue;

        vector<int> :: iterator it;
        for (it = con[nod].begin(); it != con[nod].end(); it++)
            if (C[nod][*it])
            {
                int nodurm = *it;
                int new_d = d[nod] + Cst[nod][*it] + old_d[nod] - old_d[*it];
                if (new_d < d[*it])
                {
                    d[*it] = new_d;
                    real_d[*it] = real_d[nod] + Cst[nod][*it];
                    ant[*it] = nod;
                    H.push(make_pair(d[*it], *it));
                }
            }
    }
    memcpy(old_d, real_d, sizeof(d));
    if (d[D] == oo)
        return false;

    int Min = oo;
    for (int aux = D; aux != S; aux = ant[aux])
        Min = min(Min, C[ant[aux]][aux]);

    FCst += Min * real_d[D];
    for (int aux = D; aux != S; aux = ant[aux])
        C[ant[aux]][aux] -= Min,
        C[aux][ant[aux]] += Min;

    return true;
}

inline bool bellmanFord()
{
    for(int i=1; i<=N; ++i)
        old_d[i] = oo;

    old_d[S] = 0;

    for (Q.push(S), inQ[S] = 1; !Q.empty(); Q.pop())
    {
        vector<int> :: iterator it;
        int i = Q.front();
        inQ[i] = 0;

        for (it = con[i].begin(); it != con[i].end(); it++)
            if (C[i][*it])
            {
                if (old_d[i] + Cst[i][*it] >= old_d[*it])
                    continue;

                old_d[*it] = old_d[i] + Cst[i][*it];
                if (inQ[*it])
                    continue;

                inQ[*it] = 1;
                Q.push(*it);
            }
    }

    if (old_d[D] == oo)
        return false;

    return true;
}

int main()
{
    freopen("fmcm.in", "rt", stdin);
    freopen("fmcm.out", "wt", stdout);

    scanf("%d%d%d%d",&N,&M,&S,&D);

    int x,y;

    while(M--)
    {
        scanf("%d%d",&x,&y);

        con[x].push_back(y);
        con[y].push_back(x);

        scanf("%d%d", &C[x][y], &Cst[x][y]);
        Cst[y][x] = -Cst[x][y];
    }

    FCst = 0;
    bellmanFord();
    for (; dijkstra(); )
    {
        bool ok = 1;
    }

    printf("%d\n", FCst);
    return 0;
}