#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;
    }
};

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;
int K;
int H[NM],Poz[NM];

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;
}

void Up (int P)
{
    if (P==1) return;

    if (Dist[H[P]]<Dist[H[P/2]])
    {
        swap(H[P],H[P/2]);
        swap(Poz[H[P]],Poz[H[P/2]]);
        Up(P/2);
    }
}

void Insert (int X)
{
    H[++K]=X;
    Poz[X]=K;
    Up(K);
}

void Down (int P)
{
    if (2*P<=K && Dist[H[2*P]]>Dist[H[K]])
    {
        swap(H[P],H[2*P]);
        swap(Poz[H[P]],Poz[H[2*P]]);
        Down(2*P);
        return;
    }
    if (2*P+1<=K && Dist[H[2*P+1]]>Dist[H[K]])
    {
        swap(H[P],H[2*P+1]);
        swap(Poz[H[P]],Poz[H[2*P+1]]);
        Down(2*P+1);
        return;
    }
}

int GetTop ()
{
    int X=H[1];
    swap(H[1],H[K]);
    swap(Poz[H[1]],Poz[H[K]]);

    Poz[H[K]]=0;
    H[K]=0;
    --K;
    Down(1);

    return X;
}

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));
    memset(Poz,0,sizeof(Poz));
    memset(H,0,sizeof(H));
    Dist[S]=0;
    K=0;
    Insert(S);

    while (K)
    {
        a=GetTop();

        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;
            if (!Poz[*it])
                Insert(*it);
            else
                Up(Poz[*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;
}