#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;
vector<int> G[NM];
vector<int>::iterator it;

int N,M,i,j,S,D,ND;
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 Dijkstra ()
{
    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 (F[a][*it]>=C[a][*it] || b+Cost[a][*it]>=Dist[*it]) continue;

            Dist[*it]=b+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+VM;
        Cost[b][a]=-d+VM;
    }

    while (Dijkstra())
    {
        FMIN=INF;

        for (i=D, ND=0; i!=S; i=T[i], ++ND)
            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;
        }

        ANS+=(Dist[D]-VM*ND)*FMIN;
    }

    g << ANS << '\n';

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