#include <fstream>
#include <vector>
#include <queue>
#include <cstring>
#define INF 0x3f3f3f3f
#define NM 360
#define nod first
#define cost second
#define VM 10100

using namespace std;

ifstream f("fmcm.in");
ofstream g("fmcm.out");

typedef pair<int, int> PI;

struct QCMP
{
    bool operator () (const PI& a, const PI& b) const
    {
        return a.cost>b.cost;
    }
};


priority_queue <PI, vector<PI>, QCMP> Q;
queue <int> QB;

vector<int> G[NM];
vector<int>::iterator it;

int N,M,i,j,S,D,ND;
int Sum;
int C[NM][NM],F[NM][NM];
int Cost[NM][NM];
int Dist[NM];
int T[NM];
int a,b,c,d;
int ANS,FMIN;

bool BF ()
{
    memset(Dist,INF,sizeof(Dist));
    Dist[S]=0;
    QB.push(S);

    while (!QB.empty())
    {
        a=QB.front();
        QB.pop();
        for (it=G[a].begin(); it!=G[a].end(); ++it)
        {
            if (C[a][*it]-F[a][*it]<=0 || Dist[a]+Cost[a][*it]>=Dist[*it]) continue;

            Dist[*it]=Dist[a]+Cost[a][*it];
            T[*it]=a;
            QB.push(*it);
        }
    }

    return Dist[D]<INF;
}

bool Dijkstra ()
{
    for (i=1; i<=N; i++)
        for (it=G[i].begin(); it!=G[i].end(); ++it)
            if (Dist[i]<INF && Dist[*it]<INF)
                Cost[i][*it]+=Dist[i]-Dist[*it];

    memset(Dist,INF,sizeof(Dist));
    Dist[S]=0;
    Q.push(make_pair(S,0));

    while (!Q.empty())
    {
        a=Q.top().nod;
        b=Q.top().second;
        Q.pop();

        if (b!=Dist[a]) continue;

        for (it=G[a].begin(); it!=G[a].end(); ++it)
        {
            if (C[a][*it]-F[a][*it]<=0 || Dist[a]+Cost[a][*it]>=Dist[*it]) continue;

            Dist[*it]=Dist[a]+Cost[a][*it];
            T[*it]=a;
            Q.push(make_pair(*it,Dist[*it]));
        }
    }

    return Dist[D]<INF;
}

int main ()
{
    f >> N >> M >> S >> D;

    for (i=1; i<=M; i++)
    {
        f >> a >> b >> c >> d;
        G[a].push_back(b);
        G[b].push_back(a);
        C[a][b]+=c;
        Cost[a][b]=d;
        Cost[b][a]=-d;
    }

    BF();
    Sum=Dist[D];

    while (Dijkstra())
    {
        FMIN=INF;

        for (i=D; i!=S; i=T[i])
            FMIN=min(FMIN,C[T[i]][i]-F[T[i]][i]);

        for (i=D; i!=S; i=T[i])
        {
            F[T[i]][i]+=FMIN;
            F[i][T[i]]-=FMIN;
        }

        Sum+=Dist[D];
        ANS+=Sum*FMIN;
    }

    g << ANS << '\n';

    f.close();
    g.close();
    return 0;
}