#include <fstream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <stack>
#include <iomanip>
#include <queue>
using namespace std;

ifstream fin("fmcm.in");
ofstream fout("fmcm.out");

#define nmax 355
vector <int> v[nmax];
int n,m,i,c[nmax][nmax],f[nmax][nmax],p[nmax],maxflow,maxcost,S,D,oldd[nmax],d[nmax],reald[nmax],cost[nmax][nmax];
bool use[nmax];

void bellmanford()
{
    queue <int> Q;
    bool inQ[nmax];
    for (i=1; i<=n; i++)
        inQ[i]=0,oldd[i]=20000000;
    Q.push(S);
    inQ[S]=1;
    oldd[S]=0;
    while (!Q.empty())
    {
        int nod=Q.front();
        Q.pop();
        inQ[nod]=0;
        for (int i=0; i<v[nod].size(); i++)
        {
            int vecin=v[nod][i];
            if (c[nod][vecin]&&oldd[nod]+cost[nod][vecin]<oldd[vecin])
            {
                oldd[vecin]=oldd[nod]+cost[nod][vecin];
                if (inQ[vecin]==0)
                    Q.push(vecin),inQ[vecin]=1;
            }
        }
    }
}

bool dijkstra()
{
    priority_queue <pair <int, int>, vector <pair <int, int> >, greater<pair <int, int> > > H;
    for (i=1; i<=n; i++)
        d[i]=20000000,p[i]=-1;
    d[S]=0;
    reald[S]=0;
    H.push(make_pair(d[S],S));
    while (!H.empty())
    {
        int nod=H.top().second,cc=H.top().first;
        H.pop();
        if (cc>d[nod])
            continue;
        for (int i=0; i<v[nod].size(); i++)
        {
            int vecin=v[nod][i];
            if (c[nod][vecin]>f[nod][vecin])
            {
                int aux=cost[nod][vecin]+oldd[nod]-oldd[vecin];
                if (cc+aux<d[vecin])
                {
                    d[vecin]=cc+aux;
                    p[vecin]=nod;
                    reald[vecin]=reald[nod]+cost[nod][vecin];
                    H.push(make_pair(d[vecin],vecin));
                }
            }
        }
    }
    if (p[D]==-1)
        return 0;
    int fmin=4000000;
    for (int nod=D; nod!=S; nod=p[nod])
        fmin=min(fmin,c[p[nod]][nod]-f[p[nod]][nod]);
    for (int nod=D; nod!=S; nod=p[nod])
    {
        f[p[nod]][nod]+=fmin;
        f[nod][p[nod]]-=fmin;
    }
    maxflow+=fmin;
    maxcost=maxcost+fmin*reald[D];
    for (i=1; i<=n; i++)
        oldd[i]=reald[i];
    return 1;
}

int main()
{
    fin >> n >> m >> S >> D;
    for (i=1; i<=m; i++)
    {
        int A,B,C,D;
        fin >> A >> B >> C >> D;
        v[A].push_back(B);
        v[B].push_back(A);
        cost[A][B]=D;
        cost[B][A]=-D;
        c[A][B]=C;
    }
    bellmanford();
    maxflow=maxcost=0;
    while (dijkstra());
    fout << maxcost << '\n';
}